12 Classes [class]

Функция-член может быть defined в своем определении класса, и в этом случае это inline функция-член, или она может быть определена вне определения своего класса, если она уже была объявлена, но не определена в определении своего класса. Определение функции-члена, которое появляется за пределами определения класса, должно появиться в области пространства имен, включающей определение класса. За исключением определений функций-членов, которые появляются вне определения класса, и за исключением явных специализаций функций-членов шаблонов классов и шаблонов функций-членов ([temp.spec]), появляющихся вне определения класса, функция-член не должна повторно объявляться.

Встроенная функция-член (статическая или нестатическая) также может быть определена вне ее определения класса, если ее объявление в определении класса или ее определение вне определения класса объявляет функцию как inline или constexpr. [  Note: Функции-члены класса в области пространства имен имеют связь с этим классом. Функции- local class члены не связаны. Смотрите [basic.link]. ] — end note 

[  Note: В программе может быть не более одного определения не встроенной функции-члена. В программе может быть несколько inline определений функции-члена. Смотрите [basic.def.odr] и [dcl.inline]. ] — end note 

Если определение функции-члена лексически находится за пределами определения ее класса, имя функции-члена должно быть уточнено именем ее класса с использованием ​::​ оператора. [  Note: Имя, используемое в определении функции-члена (то есть при parameter-declaration-clauseвключении default arguments или в теле функции-члена) ищется, как описано в [basic.lookup]. ] [ — end note  Example:

struct X {
  typedef int T;
  static T count;
  void f(T);
};
void X::f(T t = count) { }

Функция-член f класса X определяется в глобальной области видимости; обозначение X​::​f указывает, что функция f является членом класса X и находится в области действия класса X. В определении функции тип параметра T относится к члену typedef, T объявленному в классе, X а аргумент по умолчанию count относится к статическому члену данных, count объявленному в классе X. ] — end example 

[ Локальные переменный или локальный типа в функции члена всегда относится к той же сущности, или нет функции члена . ] Note: static inline — end note 

В объявлениях могут упоминаться ранее объявленные функции-члены friend .

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

[  Note: Функция-член может быть объявлена ​​(но не определена) с использованием typedef для типа функции. Результирующая функция-член имеет точно такой же тип, как если бы декларатор функции был указан явно, см [dcl.fct]. Например,

typedef void fv();
typedef void fvc() const;
struct S {
  fv memfunc1;      // equivalent to: void memfunc1();
  void memfunc2();
  fvc memfunc3;     // equivalent to: void memfunc3() const;
};
fv  S::* pmfv1 = &S::memfunc1;
fv  S::* pmfv2 = &S::memfunc2;
fvc S::* pmfv3 = &S::memfunc3;

Также см [temp.arg]. ] — end note 

Нестатическая функция-член может быть вызвана для объекта своего типа класса или для объекта класса derived из его типа класса с использованием class member access синтаксиса ([over.match.call]). Нестатическая функция-член также может быть вызвана напрямую с использованием синтаксиса вызова функции ([expr.call], [over.match.call]) из тела функции-члена своего класса или класса, производного от этого класса.

Если нестатическая функция-член класса X вызывается для объекта, не относящегося к типу Xили производному от него X, поведение не определено.

Когда объект, id-expressionкоторый не является частью class member access синтаксиса и не используется для формирования указателя на member ([expr.unary.op]), используется в члене класса X в контексте, где this может использоваться, если name lookup разрешает имя в id-expressionнестатическом члене, не являющемся типом некоторого класса C, и если либо id-expressionпотенциально оценивается, либо C является X базовым классом X, то id-expressionпреобразуется в class member access выражение, использующее (*this) в postfix-expression качестве слева от . оператора. [  Note: Если C не X является базовым классом или Xявляется некорректным выражением доступа к члену класса. ] Аналогично во время поиска имени, когда используемый в определении функции-члена для класса разрешается в статический член, перечислитель или вложенный тип класса или базового класса , преобразуется в, в котором имена класса функции-члена. Эти преобразования не применяются в контексте определения шаблона ( ). [ — end note unqualified-id X X Xunqualified-idqualified-idnested-name-specifier[temp.dep.type] Example:

struct tnode {
  char tword[20];
  int count;
  tnode* left;
  tnode* right;
  void set(const char*, tnode* l, tnode* r);
};

void tnode::set(const char* w, tnode* l, tnode* r) {
  count = strlen(w)+1;
  if (sizeof(tword)<=count)
      perror("tnode string too long");
  strcpy(tword,w);
  left = l;
  right = r;
}

void f(tnode n1, tnode n2) {
  n1.set("abc",&n2,0);
  n2.set("def",0,0);
}

В теле функции члена tnode​::​set, имена членов tword, count, leftи right обратиться к членам объекта , для которого эта функция вызывается. Таким образом, в вызове n1.set("abc",&n2,0), tword относится к n1.tword, а в вызове n2.set("def",0,0), он относится к n2.tword. Функции strlen, perrorи strcpy не являются членами класса tnode и должны быть объявлены в другом месте. ]110  — end example 

Функция - член нестатический может быть объявлена const, volatileили const volatile. Это cv-qualifiers влияет на тип файла this pointer. Они также влияют function type на функцию-член; функция - член объявлена const является const функция, функция - член объявлена volatile является volatile функцией членом и функция объявлена членом const volatile является const volatile функцией - членом. [ Example:

struct X {
  void g() const;
  void h() const volatile;
};

X​::​g является const функцией членом и X​::​h является const volatile функцией - членом. ] — end example 

Нестатическая функция-член может быть объявлена ​​с помощью ref-qualifier([dcl.fct]); см [over.match.funcs].

Нестатическая функция-член может быть объявлена virtual ([class.virtual]) или pure virtual ([class.abstract]).

На статический член s класса X можно ссылаться с помощью qualified-idвыражения X​::​s; нет необходимости использовать class member access синтаксис для ссылки на статический член. На статический член можно ссылаться с использованием синтаксиса доступа к члену класса, и в этом случае вычисляется выражение объекта. [ Example:

struct process {
  static void reschedule();
};
process& g();

void f() {
  process::reschedule();        // OK: no object necessary
  g().reschedule();             // g() is called
}

 — end example ]

На статический член можно ссылаться непосредственно в области его класса или в области действия класса derived из своего класса; В этом случае статический член упоминаются как если qualified-idиспользовалось выражение, с nested-name-specifierиз qualified-idимен в области видимости класса , из которого ссылается статический член. [ Example:

int g();
struct X {
  static int g();
};
struct Y : X {
  static int i;
};
int Y::i = g();                 // equivalent to Y​::​g();

 — end example ]

Если unqualified-idиспользуется в определении статического члена, следующего за членом declarator-id, и name lookup обнаруживается, что это unqualified-idотносится к статическому члену, перечислителю или вложенному типу класса члена (или базового класса класса члена), то unqualified-idпреобразуется в qualified-idвыражение , в котором nested-name-specifierимена класс сферы применения , из которого ссылается элемент. [  Note: См. [expr.prim] Ограничения на использование нестатических элементов данных и нестатических функций-членов. ] — end note 

Статические члены подчиняются обычному классу member access rules. При использовании в объявлении члена класса static спецификатор должен использоваться только в объявлениях члена, которые появляются внутри member-specificationопределения класса. [  Note: Его нельзя указывать в объявлениях членов, которые появляются в области пространства имен. ] — end note 

А member-declaratorформы

identifier${}_{opt}$  attribute-specifier-seq${}_{opt}$ : constant-expression

указывает битовое поле; его длина отделяется от имени битового поля двоеточием. Необязательный параметр attribute-specifier-seqотносится к объявляемой сущности. Атрибут битового поля не является частью типа члена класса. constant-expressionДолжна быть интегральным выражением постоянная с большим значением , чем или равно нуль. Значение выражения интегральной константы может быть больше, чем количество бит в object representation типе битового поля; в таких случаях дополнительные биты используются как биты заполнения и не участвуют в value representation битовом поле. Размещение битовых полей внутри объекта класса определяется реализацией. Выравнивание битовых полей определяется реализацией. Битовые поля упакованы в некоторую адресуемую единицу распределения. [  Note: Битовые поля охватывают единицы распределения на одних машинах, но не на других. Битовые поля назначаются справа налево на одних машинах, слева направо на других. ] — end note 

Объявление для битового поля, в котором не identifier объявляется unnamed bit-field. Безымянные битовые поля не являются членами и не могут быть инициализированы. [  Note: Безымянное битовое поле полезно для заполнения, чтобы соответствовать внешним макетам. ] В качестве особого случая безымянное битовое поле с нулевой шириной определяет выравнивание следующего битового поля на границе единицы распределения. Только при объявлении безымянного битового поля значение поля может быть равно нулю. — end note constant-expression

Битовое поле не должно быть статическим членом. Битовое поле должно иметь целочисленный или перечислительный тип ([basic.fundamental]). Значение может успешно быть сохранены в битовое поле любого размера ненулевой. Оператор адресации не должен применяться к битовому полю, поэтому нет указателей на битовые поля. Неконстантная ссылка не должна быть привязана к битовому полю ( ). [ Если инициализатором для ссылки типа является lvalue, которое относится к битовому полю, ссылка привязывается к временному инициализированному объекту для хранения значения битового поля; ссылка не связана напрямую с битовым полем. Смотрите . ] bool & [dcl.init.ref] Note: const T& [dcl.init.ref] — end note 

Если значение true или false сохраняется в битовом поле bool любого размера (включая однобитовое битовое поле), исходное bool значение и значение битового поля должны сравниваться как равные. Если значение перечислителя хранится в битовом поле того же типа перечисления, а количество битов в битовом поле достаточно велико, чтобы содержать все его значения enumeration type, исходное значение перечислителя и значение битового поля. поле сравнивать равно. [ Example:

enum BOOL { FALSE=0, TRUE=1 };
struct A {
  BOOL b:1;
};
A a;
void f() {
  a.b = TRUE;
  if (a.b == TRUE)              // yields true
    { /* ... */ }
}

 — end example ]

Класс может быть объявлен внутри другого класса. Класс, объявленный внутри другого, называется nested классом. Имя вложенного класса является локальным для включающего его класса. Вложенный класс находится в области его включающего класса. [  Note: См. [expr.prim] Ограничения на использование нестатических элементов данных и нестатических функций-членов. ] — end note 

[ Example:

int x;
int y;

struct enclose {
  int x;
  static int s;

  struct inner {
    void f(int i) {
      int a = sizeof(x);        // OK: operand of sizeof is an unevaluated operand
      x = i;                    // error: assign to enclose​::​x
      s = i;                    // OK: assign to enclose​::​s
      ::x = i;                  // OK: assign to global x
      y = i;                    // OK: assign to global y
    }
    void g(enclose* p, int i) {
      p->x = i;                 // OK: assign to enclose​::​x
    }
  };
};

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

 — end example ]

Функции-члены и статические элементы данных вложенного класса могут быть определены в области пространства имен, включающей определение их класса. [ Example:

struct enclose {
  struct inner {
    static int x;
    void f(int i);
  };
};

int enclose::inner::x = 1;

void enclose::inner::f(int i) { /* ... */ }

 — end example ]

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

class E {
  class I1;                     // forward declaration of nested class
  class I2;
  class I1 { };                 // definition of nested class
};
class E::I2 { };                // definition of nested class

 — end example ]

Как и функция-член, friend function определенный внутри вложенного класса находится в лексической области видимости этого класса; он подчиняется тем же правилам привязки имен, static member function что и класс этого класса, но не имеет особых прав доступа к членам включающего класса.

Имена типов подчиняются точно таким же правилам области видимости, как и другие имена. В частности, имена типов, определенные в определении класса, не могут использоваться вне своего класса без уточнения. [ Example:

struct X {
  typedef int I;
  class Y { /* ... */ };
  I a;
};

I b;                            // error
Y c;                            // error
X::Y d;                         // OK
X::I e;                         // OK

 — end example ]