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

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

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);
• нестатический элемент данных не может иметь то же имя, что и имя класса, если присутствует хотя бы один объявленный пользователем конструктор;

Кроме того, разрешены объявления битовых полей.

Компоновка

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

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

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

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

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 пуста

Два типа класса не объединения со стандартной компоновкой называются совместимыми по компоновке, если они относятся к одному типу, игнорируя 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) {} // прямая инициализация n, инициализация по умолчанию s

};

struct S
{
    int n = 7;
    std::string s{'a', 'b', 'c'};
    S() {} // инициализатор элемента по умолчанию будет инициализировать копией n,
        // инициализировать списком s

};

#include <iostream>

int x = 0;
struct S
{
    int n = ++x;
    S() { }                 // использует инициализатор элемента по умолчанию
    S(int arg) : n(arg) { } // использует инициализатор элемента
};

int main()
{
    std::cout << x << '\n'; // печатает 0
    S s1;                   // инициализатор по умолчанию выполнен
    std::cout << x << '\n'; // печатает 1
    S s2(7);                // инициализатор по умолчанию не выполнен
    std::cout << x << '\n'; // печатает 1
}

struct X
{
   int a[] = {1,2,3};  // ошибка
   int b[3] = {1,2,3}; // OK
};

struct node {
    node* p = new node; // ошибка: использование неявного или заданного по умолчанию
                        // node::node()
};

struct A
{
    A() = default;          // OK
    A(int v) : v(v) { }     // OK
    const int& v = 42;      // OK
};
A a1;    // ошибка: неверно сформированная привязка временного объекта к ссылке
A a2(1); // OK (инициализатор элемента по умолчанию игнорируется, поскольку v появляется
         // в конструкторе)
         // однако a2.v это висячая ссылка

struct A;
extern A a;
struct A
{
    const A& a1{ A{a, a}}; // OK
    const A& a2{ A{}};     // ошибка
};
A a{a, a};                  // OK

Применение

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

struct S
{
    int m;
    int n;
    int x = m;            // OK: неявный this-> разрешён в инициализаторах
                          // по умолчанию (C++11)
    S(int i) : m(i), n(m) // OK: неявный this-> разрешён в списках
                          // инициализаторов элементов
    {
        this->f();        // явное выражение доступа к элементу
        f();              // неявный this-> разрешён в телах функций-элементов
    }
    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: хотя для m не существует объекта "this"

Примечание

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

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

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