Classes and class hierarchies

C.13

Если член данных `B` использует другой член данных `A`, объявляйте `A` перед `B`

Причина

Члены данных инициализируются в порядке их объявления и уничтожаются в обратном порядке.

Обсуждение

Если член данных B использует другой член данных A, то A должен быть объявлен перед B, чтобы A переживал B, то есть время жизни A начинается раньше и заканчивается позже времени жизни B. В противном случае при конструировании и уничтожении B будет пытаться использовать A вне его времени жизни.

Пример (плохой)

// Плохо: b использует a, но a объявлен после b.
//      Порядок конструирования: b затем a; порядок уничтожения: a затем b.
//      Поэтому b обращается к a вне его времени жизни.

class X {
    struct B {
        string* p;
        explicit B(string& a) : p{&a} {}
        ~B() { cout << *p; }                       // использует a (через p)
    };

    B      b;                                      // конструируется первым
    string a = "some heap allocated string value"; // конструируется после b; уничтожается до b

public:
    X() : b{a} {}   // использует a до его конструирования -> UB (use-before-alloc)
    ~X() = default; // обращается к a после его уничтожения -> UB (use-after-free)
};

Пример (хороший)

// Исправлено: просто объявляем a перед b

class X {
    struct B {
        string* p;
        explicit B(string& a) : p{&a} {}
        ~B() { cout << *p; }                       // использует a (через p)
    };

    string a = "some heap allocated string value"; // конструируется до b; уничтожается после b
    B      b;                                      // конструируется вторым

public:
    X() : b{a} {}   // ok
    ~X() = default; // ok
};

Пример (плохой)

Это также может возникнуть при конкурентном выполнении. Убедитесь, что асинхронная операция, обращающаяся к значению, завершена до уничтожения этого значения.

class X {
public:
    X()
        : a{std::make_unique<int>(12)} 
    {
        b = std::make_unique<std::jthread>(
            [this]{
            std::this_thread::sleep_for(std::chrono::seconds(1));
            std::cout << "Value: " << *a << std::endl;
          });
    }

    std::unique_ptr<std::jthread> b;
    std::unique_ptr<int>          a;
};

Пример (хороший)

// Исправлено: просто объявляем a перед b

class X {
public:
    X()
        : a{std::make_unique<int>(12)}
    {
        b = std::make_unique<std::jthread>(
            [this]{
            std::this_thread::sleep_for(std::chrono::seconds(1));
            std::cout << "Value: " << *a << std::endl;
          });
    }

    std::unique_ptr<int>          a;
    std::unique_ptr<std::jthread> b;
};

Контроль

Помечать инициализатор члена, который ссылается на объект до его конструирования.

C.ctor: Конструкторы, присваивание и деструкторы

Эти функции управляют жизненным циклом объектов: созданием, копированием, перемещением и уничтожением. Определяйте конструкторы для гарантии и упрощения инициализации классов.

Это операции по умолчанию:

конструктор по умолчанию: X()
конструктор копирования: X(const X&)
оператор копирующего присваивания: operator=(const X&)
конструктор перемещения: X(X&&)
оператор перемещающего присваивания: operator=(X&&)
деструктор: ~X()

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

Операции по умолчанию — это набор связанных операций, которые вместе реализуют семантику жизненного цикла объекта. По умолчанию C++ рассматривает классы как типы-значения, но не все типы являются значениями.

Правила для набора операций по умолчанию:

Правила для деструкторов:

Правила для конструкторов:

Правила для копирования и перемещения:

Прочие правила для операций по умолчанию:

C.defop: Операции по умолчанию

По умолчанию язык предоставляет операции по умолчанию с их семантикой по умолчанию. Однако программист может отключить или заменить эти значения по умолчанию.

Открыть на isocpp.github.io →

Classes and class hierarchies

C.13

Если член данных `B` использует другой член данных `A`, объявляйте `A` перед `B`

Причина

Члены данных инициализируются в порядке их объявления и уничтожаются в обратном порядке.

Обсуждение

Пример (плохой)

// Плохо: b использует a, но a объявлен после b.
//      Порядок конструирования: b затем a; порядок уничтожения: a затем b.
//      Поэтому b обращается к a вне его времени жизни.

class X {
    struct B {
        string* p;
        explicit B(string& a) : p{&a} {}
        ~B() { cout << *p; }                       // использует a (через p)
    };

    B      b;                                      // конструируется первым
    string a = "some heap allocated string value"; // конструируется после b; уничтожается до b

public:
    X() : b{a} {}   // использует a до его конструирования -> UB (use-before-alloc)
    ~X() = default; // обращается к a после его уничтожения -> UB (use-after-free)
};

Пример (хороший)

// Исправлено: просто объявляем a перед b

class X {
    struct B {
        string* p;
        explicit B(string& a) : p{&a} {}
        ~B() { cout << *p; }                       // использует a (через p)
    };

    string a = "some heap allocated string value"; // конструируется до b; уничтожается после b
    B      b;                                      // конструируется вторым

public:
    X() : b{a} {}   // ok
    ~X() = default; // ok
};

Пример (плохой)

class X {
public:
    X()
        : a{std::make_unique<int>(12)} 
    {
        b = std::make_unique<std::jthread>(
            [this]{
            std::this_thread::sleep_for(std::chrono::seconds(1));
            std::cout << "Value: " << *a << std::endl;
          });
    }

    std::unique_ptr<std::jthread> b;
    std::unique_ptr<int>          a;
};

Пример (хороший)

// Исправлено: просто объявляем a перед b

class X {
public:
    X()
        : a{std::make_unique<int>(12)}
    {
        b = std::make_unique<std::jthread>(
            [this]{
            std::this_thread::sleep_for(std::chrono::seconds(1));
            std::cout << "Value: " << *a << std::endl;
          });
    }

    std::unique_ptr<int>          a;
    std::unique_ptr<std::jthread> b;
};

Контроль

Помечать инициализатор члена, который ссылается на объект до его конструирования.

C.ctor: Конструкторы, присваивание и деструкторы

Это операции по умолчанию:

конструктор по умолчанию: X()
конструктор копирования: X(const X&)
оператор копирующего присваивания: operator=(const X&)
конструктор перемещения: X(X&&)
оператор перемещающего присваивания: operator=(X&&)
деструктор: ~X()

Правила для набора операций по умолчанию:

Правила для деструкторов:

Правила для конструкторов:

Правила для копирования и перемещения:

Прочие правила для операций по умолчанию:

C.defop: Операции по умолчанию

Открыть на isocpp.github.io →