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

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

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 через не-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++.

См. также