Нестатические члены данных

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

class S
{
    int n;              // non-static data member
    int& r;             // non-static data member of reference type
    int a[2] = {1, 2};  // non-static data member with default member initializer (C++11)
    std::string s, *ps; // two non-static data members
    
    struct NestedS
    {
        std::string s;
    } d5;               // non-static data member of nested type
    
    char bit : 2;       // two-bit bitfield
};

Допускаются любые простые объявления, кроме следующих:

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

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

Кроме того, допускаются объявления битовых полей.

Размещение

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

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

Стандартное размещение

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

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

struct A { int a; char b; };
struct B { const int b1; volatile char b2; }; 
// A and B's common initial sequence is A.a, A.b and B.b1, B.b2

struct C { int c; unsigned : 0; char b; };
// A and C's common initial sequence is A.a and C.c

struct D { int d; char b : 4; };
// A and D's common initial sequence is A.a and D.d

struct E { unsigned int e; char b; };
// A and E's common initial sequence is empty

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

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

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

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

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

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

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: use of m to make a pointer to member
void (S::*fp)() = &S::f; // OK: use of f to make a pointer to member

struct S
{
    int m;
    static const std::size_t sz = sizeof m; // OK: m in unevaluated operand
};

std::size_t j = sizeof(S::m + 42); // OK: even though there is no "this" object for m

Примечания

Отчёты об ошибках

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

См. также