Non-static data members

Нестатические члены данных объявляются в спецификации членов класса.

class S
{
    int n;              // нестатический член данных
    int& r;             // нестатический член данных ссылочного типа
    int a[2] = {1, 2};  // нестатический член данных с инициализатором по умолчанию (C++11)
    std::string s, *ps; // два нестатических члена данных
    struct NestedS
    {
        std::string s;
    } d5;               // нестатический член данных вложенного типа
    char bit : 2;       // двухбитовое битовое поле
};

Любые простые объявления разрешены, за исключением

• extern и register спецификаторы класса хранения не допускаются;

• неполные типы , абстрактные классы и их массивы не допускаются: в частности, класс C не может иметь нестатический член данных типа C , хотя он может иметь нестатический член данных типа C& (ссылка на C) или C* (указатель на C );
• нестатический член данных не может иметь то же имя, что и имя класса, если присутствует хотя бы один пользовательский конструктор;

Кроме того, bit-field объявления разрешены.

Компоновка

Когда объект некоторого класса C создается, каждый нестатический член данных нессылочного типа размещается в некоторой части представления объекта C . Занимают ли ссылочные члены память, определяется реализацией, но их storage duration совпадает с продолжительностью хранения объекта, членами которого они являются.

Требования выравнивания могут потребовать заполнения между членами или после последнего члена класса.

Стандартная компоновка

общая начальная последовательность двух типов стандартной компоновки, не являющихся объединениями, представляет собой самую длинную последовательность нестатических членов данных и битовых полей в порядке объявления, начиная с первой такой сущности в каждом из классов, такая что

• соответствующие сущности имеют layout-совместимые типы,
• соответствующие сущности имеют одинаковые требования к выравниванию , и
• либо обе сущности являются битовыми полями одинаковой ширины, либо ни одна из них не является битовым полем.

struct A { int a; char b; };
struct B { const int b1; volatile char b2; }; 
// Общая начальная последовательность A и B: A.a, A.b и B.b1, B.b2
struct C { int c; unsigned : 0; char b; };
// Общая начальная последовательность A и C: A.a и C.c
struct D { int d; char b : 4; };
// Общая начальная последовательность A и D: A.a и D.d
struct E { unsigned int e; char b; };
// Общая начальная последовательность A и E: пустая

Два типа не-объединений со стандартной компоновкой называются layout-compatible (совместимыми по компоновке), если они являются одним и тем же типом без учета cv-квалификаторов (если таковые имеются), являются layout-compatible перечислениями (т.е. перечислениями с одинаковым базовым типом), или если их common initial sequence (общая начальная последовательность) состоит из каждого нестатического члена данных и битового поля (в примере выше, A и B являются layout-compatible).

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

Стандартно-компонуемые типы обладают следующими особыми свойствами:

• В стандартном layout-объединении с активным членом не-объединенного типа класса T1 разрешается читать нестатический член данных m другого члена объединения не-объединенного типа класса T2 при условии, что m является частью общей начальной последовательности T1 и T2 (за исключением того, что чтение volatile-члена через не-volatile glvalue является неопределенным поведением).
• Указатель на объект стандартного layout-типа класса может быть reinterpret_cast в указатель на его первый нестатический не-битовый член данных (если он имеет нестатические члены данных) или в указатель на любой из его базовых подобъектов (если они есть), и наоборот. Другими словами, выравнивание не допускается перед первым членом данных стандартного layout-типа. Обратите внимание, что правила строгого псевдонимирования все еще применяются к результату такого приведения.
• Макрос offsetof может использоваться для определения смещения любого члена от начала стандартного layout-класса.

Инициализация членов класса

Нестатические члены данных могут быть инициализированы одним из двух способов:

struct S
{
    int n;
    std::string s;
    S() : n(7) {} // direct-initializes n, default-initializes s
};

struct S
{
    int n = 7;
    std::string s{'a', 'b', 'c'};
    S() {} // default member initializer will copy-initialize n, list-initialize s
};

#include <iostream>
int x = 0;
struct S
{
    int n = ++x;
    S() {}                 // uses default member initializer
    S(int arg) : n(arg) {} // uses member initializer 
};
int main()
{
    std::cout << x << '\n'; // prints 0
    S s1;                   // default initializer ran
    std::cout << x << '\n'; // prints 1
    S s2(7);                // default initializer did not run
    std::cout << x << '\n'; // prints 1
}

struct X
{
    int a[] = {1, 2, 3};  // error
    int b[3] = {1, 2, 3}; // OK
};

struct node
{
    node* p = new node; // error: use of implicit or defaulted node::node() 
};

struct A
{
    A() = default;     // OK
    A(int v) : v(v) {} // OK
    const int& v = 42; // OK
};
A a1;    // error: ill-formed binding of temporary to reference
A a2(1); // OK (default member initializer ignored because v appears in a constructor)
         // however a2.v is a dangling reference

struct A;
extern A a;
struct A
{
    const A& a1{A{a, a}}; // OK
    const A& a2{A{}};     // error
};
A a{a, a};                // OK

Использование

Имя нестатического члена данных или нестатической функции-члена может появляться только в следующих трёх ситуациях:

struct S
{
    int m;
    int n;
    int x = m;            // OK: implicit this-> allowed in default initializers (C++11)
    S(int i) : m(i), n(m) // OK: implicit this-> allowed in member initializer lists
    {
        this->f();        // explicit member access expression
        f();              // implicit this-> allowed in member function bodies
    }
    void f();
};

struct S
{
    int m;
    void f();
};
int S::*p = &S::m;       // OK: использование m для создания указателя на член
void (S::*fp)() = &S::f; // OK: использование f для создания указателя на член

struct S
{
    int m;
    static const std::size_t sz = sizeof m; // OK: m в невычисляемом операнде
};
std::size_t j = sizeof(S::m + 42); // OK: даже несмотря на отсутствие объекта "this" для m

Примечания

Отчёты о дефектах

Следующие отчеты об изменениях в поведении, являющиеся дефектными, были применены ретроактивно к ранее опубликованным стандартам C++.

Смотрите также