12 Classes [class]

Определение класса вводит новый тип. [ Example:

struct X { int a; };
struct Y { int a; };
X a1;
Y a2;
int a3;

объявляет три переменные трех разных типов. Это означает, что

a1 = a2;                        // error: Y assigned to X
a1 = a3;                        // error: int assigned to X

несоответствия типов, и что

int f(X);
int f(Y);

объявить overloaded функцию, f() а не просто одну функцию f() дважды. По той же причине,

struct S { int a; };
struct S { int a; };            // error, double definition

неправильно сформирован, потому что он определяет S дважды. ] — end example 

Объявление класса вводит имя класса в область, в которой оно объявлено, и скрывает любой класс, переменную, функцию или другое объявление с этим именем во вложении scope. Если имя класса объявлено в области, где также объявлены переменная, функция или перечислитель с тем же именем, тогда, когда оба объявления находятся в области видимости, на класс можно ссылаться только с помощью elaborated-type-specifier([basic.lookup.elab]). [ Example:

struct stat {
  // ...
};

stat gstat;                     // use plain stat to define variable

int stat(struct stat*);         // redeclare stat as function

void f() {
  struct stat* ps;              // struct prefix needed to name struct stat
  stat(ps);                     // call stat()
}

 — end example ] A, состоящий исключительно из, является либо повторным объявлением имени в текущей области, либо прямым объявлением идентификатора как имени класса. Он вводит имя класса в текущую область видимости. [declarationclass-key identifier;  Example:

struct s { int a; };

void g() {
  struct s;                     // hide global struct s with a block-scope declaration
  s* p;                         // refer to local struct s
  struct s { char* p; };        // define local struct s
  struct s;                     // redeclaration, has no effect
}

 — end example ] [  Note: Такие объявления позволяют определять классы, которые ссылаются друг на друга. [ Example:

class Vector;

class Matrix {
  // ...
  friend Vector operator*(const Matrix&, const Vector&);
};

class Vector {
  // ...
  friend Vector operator*(const Matrix&, const Vector&);
};

Объявление friends описано в [class.friend], операторные функции - в [over.oper]. ] ] — end example  — end note 

[  Note: An elaborated-type-specifierтакже может использоваться type-specifierкак часть объявления. Он отличается от объявления класса тем, что, если класс с подробным именем находится в области видимости, разработанное имя будет ссылаться на него. ] [ — end note  Example:

struct s { int a; };

void g(int s) {
  struct s* p = new struct s;   // global s
  p->a = s;                     // parameter s
}

 — end example ]

[  Note: Объявление имени класса вступает в силу сразу после того, как identifierбудет замечено в определении класса или elaborated-type-specifier. Например,

class A * A;

first указывает, A что это имя класса, а затем переопределяет его как имя указателя на объект этого класса. Это означает, что class A для ссылки на класс необходимо использовать разработанную форму . Такой артистизм с именами может сбивать с толку, и его лучше избегать. ] — end note 

Имя typedef-nameтипа класса или его cv-квалифицированная версия также является class-name. Если a, typedef-nameкоторый именует тип класса cv-Qualified, используется там, где a class-nameтребуется, cv-квалификаторы игнорируются. А typedef-nameне должно использоваться как identifierв class-head.

В member-specificationопределении класса объявляется полный набор членов класса; ни один участник не может быть добавлен в другое место. A direct member класса X - это член, X который был впервые объявлен внутри member-specificationкласса X, включая анонимные объекты объединения ([class.union.anon]) и их прямые члены. Члены класса - это члены данных member functions, вложенные типы, перечислители member templates и их специализации. [  Note: Специализацией шаблона статического элемента данных является статический член данных. Специализацией шаблона функции-члена является функция-член. Специализацией шаблона класса-члена является вложенный класс. ] — end note 

A member-declarationне объявляет новых членов класса, если он

• (2.1)

  а friend declaration,

• (2.2)

  а static_assert-declaration,

• (2.3)

  а using-declaration, или

• (2.4)

  ан empty-declaration.

Для любого другого member-declarationкаждый объявленный объект, который не является, unnamed bit-field является членом класса, и каждый такой member-declaration должен либо объявить по крайней мере одно имя члена класса, либо объявить по крайней мере одно безымянное битовое поле.

A data member - нефункциональный член, представленный a member-declarator. A member function - это член, являющийся функцией. Вложенные типы - это классы ([class.name], [class.nest]), enumerations объявленные в классе, и произвольные типы, объявленные как члены с помощью символа typedef declaration или alias-declaration. Перечислители unscoped enumeration определенного в классе являются членами класса.

Член данных или функция - член может быть объявлена static в его member-declaration, в этом случае он является static member (см [class.static]) (а static data member ([class.static.data]) или static member function ([class.static.mfct]) соответственно) класса. Любой другой член данных или функция-член - это non-static member (a non-static data member или non-static member function ([class.mfct.non-static]) соответственно). [  Note: Нестатический член данных не ссылочного типа является подобъектом члена объекта класса ([intro.object]). ] — end note 

Член не может быть объявлен дважды в группе member-specification, за исключением того, что

• (5.1)

  шаблон вложенного класса или класса-члена может быть объявлен, а затем определен позже, и

• (5.2)

  перечисление можно ввести с помощью, opaque-enum-declarationа затем повторно объявить с помощью enum-specifier.

[  Note: Одно имя может обозначать несколько функций-членов при условии, что их типы существенно различаются (пункт [over]). ] — end note 

Класс считается полностью определенным типом объекта ([basic.types]) (или полный типом) , при закрытии } из class-specifier. Внутри класса member-specificationкласс считается завершенным в телах функций, аргументах по noexcept-specifiersумолчанию и инициализаторах членов по умолчанию (включая такие вещи во вложенных классах). В противном случае он считается неполным в рамках своего класса member-specification.

В a member-declarator, = следующий за declarator ним интерпретируется как вводящий, pure-specifier если у declarator-idнего есть тип функции, в противном случае он интерпретируется как вводящий brace-or-equal-initializer. [ Example:

struct S {
  using T = void();
  T * p = 0;        // OK: brace-or-equal-initializer
  virtual T f = 0;  // OK: pure-specifier
};

 — end example ]

A brace-or-equal-initializerдолжен появляться только в объявлении элемента данных. (Для статических элементов данных см [class.static.data].; Для нестатических элементов данных см. [class.base.init] И [dcl.init.aggr]). A brace-or-equal-initializerдля нестатического члена данных указывает a default member initializer для члена и не должен прямо или косвенно вызывать неявное определение конструктора по умолчанию по умолчанию для включающего класса или спецификации исключения этого конструктора.

Член не может быть объявлен с . В определении класса член не должен объявляться с помощью, если он также не объявлен . extern storage-class-specifier thread_­local storage-class-specifier static

decl-specifier-seqМожет быть опущен только в деклараций конструктор, деструктор и функция преобразования; при объявлении другого типа члена в нем decl-specifier-seq должен содержаться a, type-specifierкоторый не является a cv-qualifier. member-declarator-listМожет быть опущен только после того, как class-specifierили enum-specifierили в friend declaration. A pure-specifierдолжен использоваться только в декларации a, virtual function которая не является friend декларацией.

Необязательный параметр attribute-specifier-seqв a member-declaration относится к каждой из сущностей, объявленных объектом member-declarators; он не должен появляться, если member-declarator-listопущено необязательное .

A virt-specifier-seqдолжен содержать не более одного каждого из них virt-specifier. А virt-specifier-seq должен фигурировать только в декларации а virtual member function.

Нестатические элементы данных не должны иметь неполных типов. В частности, класс C не должен содержать нестатического члена класса C, но он может содержать указатель или ссылку на объект класса C.

[  Note: См. [expr.prim] Ограничения на использование нестатических элементов данных и нестатических функций-членов. ] — end note 

[  Note: Тип нестатической функции-члена - это обычный тип функции, а тип нестатического члена данных - это обычный тип объекта. Не существует специальных типов функций-членов или типов данных-членов. ] — end note 

[  Example: Простой пример определения класса:

struct tnode {
  char tword[20];
  int count;
  tnode* left;
  tnode* right;
};

который содержит массив из двадцати символов, целого числа и двух указателей на объекты одного типа. После того, как это определение было дано, декларация

tnode s, *sp;

объявляет s как tnode и sp как указатель на tnode. С помощью этих объявлений sp->count относится к count члену объекта, на который sp указывает; s.left ссылается на left указатель поддерева объекта s; и s.right->tword[0] относится к начальному символу tword члена right поддерева s. ] — end example 

Нестатические элементы данных класса (не объединенного) с тем же самым access control выделяются так, чтобы более поздние члены имели более высокие адреса в объекте класса. Порядок распределения нестатических членов данных с разными access control не определен. Требования согласования реализации могут привести к тому, что два соседних элемента не будут размещены сразу после друг друга; так что требования к пространству для управления virtual functions и виртуального base classes.

Если T это имя класса, то каждое из следующих имен должно иметь имя, отличное от T:

• (18.1)

  каждый статический член данных класса T;

• (18.2)

  каждая функция-член класса T [  Note: Это ограничение не распространяется на те constructors, у которых нет имен ]; — end note 

• (18.3)

  каждый член класса, T который сам является типом;

• (18.4)

  каждый шаблон члена класса T;

• (18.5)

  каждый перечислитель каждого члена класса, T который является перечислимым типом без области действия; а также

• (18.6)

  каждый член каждого анонимного союза, который является членом класса T.

Кроме того, если класс T объявлен пользователем constructor, каждый нестатический член данных класса T должен иметь имя, отличное от T.

common initial sequence Двух standard-layout struct типов является самой длинной последовательности нестатические элементов данных и битовых полей в порядке декларации, начиная с первого такого лица в каждой из структур, таким образом, что соответствующие лица имеют макет-совместимых типов и либо ни юридическое лицо немного -field или оба являются битовыми полями с одинаковой шириной. [ Example:

  struct A { int a; char b; };
  struct B { const int b1; volatile char b2; };
  struct C { int c; unsigned : 0; char b; };
  struct D { int d; char b : 4; };
  struct E { unsigned int e; char b; };

Общая начальная последовательность A и B включает всех членов любого класса. Общая начальная последовательность A and C и of A и D включает в себя первый член в каждом случае. Общая начальная последовательность A и E пуста. ] — end example 

Два standard-layout struct типа - это layout-compatible classes если их общая начальная последовательность включает все члены и битовые поля обоих классов ([basic.types]).

Два объединения со стандартным макетом совместимы с макетом, если они имеют одинаковое количество нестатических элементов данных и соответствующие нестатические элементы данных (в любом порядке) layout-compatible types.

В объединении стандартного макета с active member типом структуры T1разрешено читать нестатический член m данных другого члена объединения с типом структуры, T2 если он m является частью общей начальной последовательности T1 и T2; поведение такое, как если бы был назначен член-корреспондент T1 . [ Example:

struct T1 { int a, b; };
struct T2 { int c; double d; };
union U { T1 t1; T2 t2; };
int f() {
  U u = { { 1, 2 } };   // active member is t1
  return u.t2.c;        // OK, as if u.t1.a were nominated
}

 — end example ] [  Note: Чтение изменчивого объекта через энергонезависимое значение glvalue имеет неопределенное поведение ([dcl.type.cv]). ] — end note 

Если объект класса стандартного макета имеет какие-либо нестатические элементы данных, его адрес совпадает с адресом его первого нестатического члена данных. В противном случае его адрес совпадает с адресом его первого подобъекта базового класса (если есть). [  Note: Следовательно, внутри объекта структуры стандартного макета может быть безымянное заполнение, но не в его начале, что необходимо для достижения надлежащего выравнивания. ] [ Объект и его первый подобъект взаимопреобразуемы по указателю ( , ). ] — end note  Note: [basic.compound] [expr.static.cast] — end note 

В объединении нестатический член данных - это active если его имя относится к объекту, lifetime который начался и не закончился. Максимум один из нестатических элементов данных объекта типа объединения может быть активным в любое время, то есть значение не более одного из нестатических элементов данных может быть сохранено в объединении в любое время. [  Note: Одна специальная гарантия дается для упрощения использования объединений: если объединение стандартного макета содержит несколько структур стандартного макета, которые совместно используют a common initial sequence, и если нестатический член данных объекта этого типа объединения стандартного макета является active и является одной из структур стандартного макета, разрешается проверять общую начальную последовательность любого из членов структуры стандартного макета; см [class.mem]. ] — end note 

Размер объединения достаточен, чтобы содержать самый большой из его нестатических элементов данных. Каждый нестатический член данных выделяется, как если бы он был единственным членом структуры. [  Note: Объект объединения и его нестатические элементы данных - это pointer-interconvertible ([expr.static.cast]). Как следствие, все нестатические элементы данных объекта объединения имеют один и тот же адрес. ] — end note 

Объединение может иметь функции-члены (включая конструкторы и деструкторы), но не должно иметь virtual функций. У союза не должно быть базовых классов. Объединение не должно использоваться в качестве базового класса. Если объединение содержит нестатический элемент данных ссылочного типа, программа имеет неправильный формат. [  Note: Отсутствует default member initializers, если не-статический член данных объединения имеет нетривиальный конструктор по умолчанию ([class.ctor]), copy constructor, конструктор перемещения ([class.copy]), copy assignment operator, move assignment operator, или destructor, соответствующая функция члена союза должна быть предоставленный пользователем или он будет неявно deleted для союза. ]  — end note 

[  Example: Рассмотрим следующий союз:

union U {
  int i;
  float f;
  std::string s;
};

Поскольку std​::​string объявляет нетривиальные версии всех специальных функций-членов, U будет неявно удален конструктор по умолчанию, конструктор копирования / перемещения, оператор присваивания / перемещения и деструктор. Для использования Uнекоторые или все эти функции-члены должны быть предоставлены пользователем. ] — end example 

Когда левый операнд оператора присваивания включает в себя, member access expression который назначает член объединения, он может начать время жизни этого члена объединения, как описано ниже. Для выражения Eопределите набор S(E) подвыражений E следующим образом:

• (5.1)

  Если E имеет форму A.B, S(E) содержит элементы S(A), а также содержит, A.B если B имена, член объединения неклассового, не-массивного типа или типа класса с тривиальным конструктором по умолчанию, который не удаляется, или массив таких типы.

• (5.2)

  Если E имеет форму A[B] и интерпретируется как встроенный оператор индексации массива, S(E) is S(A) if A имеет тип массива, S(B) if B имеет тип массива и пусто в противном случае.

• (5.3)

  В противном случае S(E) пусто.

В выражении присваивания формы , E1 = E2 которая использует либо built-in assignment operator или trivial assignment operator, для каждого элемента X из S(E1), если модификация X будет иметь неопределенное поведение под [basic.life], объектом типа X неявно создаются в выдвинутом хранении; инициализация не выполняется, и начало его жизненного цикла упорядочивается после вычисления значений левого и правого операндов и перед назначением. [На  Note: этом заканчивается lifetime членство ранее активного члена союза, если таковой имеется. ] [ — end note  Example:

union A { int x; int y[4]; };
struct B { A a; };
union C { B b; int k; };
int f() {
  C c;                  // does not start lifetime of any union member
  c.b.a.y[3] = 4;       // OK: S(c.b.a.y[3]) contains c.b and c.b.a.y;
                        // creates objects to hold union members c.b and c.b.a.y
  return c.b.a.y[3];    // OK: c.b.a.y refers to newly created object (see [basic.life])
}

struct X { const int a; int b; };
union Y { X x; int k; };
void g() {
  Y y = { { 1, 2 } };   // OK, y.x is active union member ([class.mem])
  int n = y.x.a;
  y.k = 4;              // OK: ends lifetime of y.x, y.k is active member of union
  y.x.b = n;            // undefined behavior: y.x.b modified outside its lifetime,
                        // S(y.x.b) is empty because X's default constructor is deleted,
                        // so union member y.x's lifetime does not implicitly start
}

 — end example ]

[  Note: В общем, new-expressionдля изменения активного члена объединения необходимо использовать явные вызовы деструктора и размещение . ] [ Рассмотрим объект из более типа , имеющей не-статические элементы данных типа и типа . Если есть ненулевая деструктор и имеет нетривиальный конструктор (например, если они объявляют или наследовать виртуальные функции), активный член может быть безопасно переключаются с с использованием деструктора и размещений следующим образом :  — end note  Example: u union U m M n N M N u m n new-expression

u.m.~M();
new (&u.n) N;

 — end example ]

Класс может быть объявлен в определении функции; такой класс называется local классом. Имя локального класса является локальным для окружающей его области видимости. Локальный класс находится в области охватывающей области и имеет такой же доступ к именам вне функции, как и включающая функция. Объявления в локальном классе не должны быть odr-use переменной с автоматической продолжительностью хранения из охватывающей области. [ Example:

int x;
void f() {
  static int s;
  int x;
  const int N = 5;
  extern int q();

  struct local {
    int g() { return x; }       // error: odr-use of automatic variable x
    int h() { return s; }       // OK
    int k() { return ::x; }     // OK
    int l() { return q(); }     // OK
    int m() { return N; }       // OK: not an odr-use
    int* n() { return &N; }     // error: odr-use of automatic variable N
  };
}

local* p = 0;                   // error: local not in scope

 — end example ]

Вмещающая функция не имеет специального доступа к членам локального класса; он подчиняется обычному access rules. Функции-члены локального класса должны быть определены в их определении класса, если они вообще определены.

Если класс X является локальным классом, вложенный класс Y может быть объявлен в классе X и позже определен в определении класса X или позже определен в той же области, что и определение класса X. Класс, вложенный в локальный класс, является локальным классом.

Локальный класс не должен иметь статических элементов данных.