Программирование C++

В классе один RAII-ресурс зависит от другого. Как порядок объявления полей определяет корректность их уничтожения?

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

Разберите, почему создание std::shared_ptr из this у уже управляемого объекта опасно.

Что происходит с объектом, на который ссылается std::weak_ptr, после уничтожения последнего std::shared_ptr?

В практической библиотеке ресурс должен освобождаться функцией close, а не delete. Как связать такой ресурс с RAII в C++?

В интерфейсе C++ функция получает сырой указатель на объект, которым владеет вызывающий код. Какие ограничения это накладывает на время жизни объекта внутри функции?

Разберите, почему циклическое владение через std::shared_ptr может продлить жизнь объектов навсегда.

Как RAII освобождает ресурс, если исключение прерывает функцию до её обычного завершения?

Что означает передача std::unique_ptr в функцию по значению с точки зрения владения ресурсом?

Функция возвращает указатель на объект, которым владеет локальный RAII-объект. Разберите последствия вызова get():

#include <iostream>
#include <memory>

int* get() {
    auto value = std::make_unique<int>(42);
    return value.get();
}

int main() {
    int* p = get();
    std::cout << *p << '
';
}

В классе закрыто поле, а внешняя функция должна обращаться к нему без публичного метода. Как механизм friend меняет проверку доступа и остаётся ли такая функция членом класса?

Представьте, что преобразование объекта производного класса к базовому доступно внутри самого класса, но запрещено вызывающему коду. Как это объясняется частным наследованием?

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

В чём принципиальная опасность привязки временного объекта к ссылочному члену в списке инициализации конструктора?

В ромбовидной иерархии наследования зачем базовый класс делают виртуальным?

Если конструктор объекта выбрасывает исключение, какие части объекта будут уничтожены?

В производном классе используют конструктор базового класса через using. Определите, как будут инициализированы базовая часть и собственное поле объекта:

#include <cassert>

struct Base {
    explicit Base(int value) : value(value) {}
    int value;
};

struct Derived : Base {
    using Base::Base;
    int status = 42;
};

int main() {
    Derived object(7);
    assert(object.value == 7);
    assert(object.status == 42);
}

Объясните механизм выбора и выполнения унаследованного конструктора.

В производном классе вызов read(Base&) не компилируется, хотя Base::value унаследован. Укажите причину, опираясь на статический тип выражения объекта.

struct Base {
protected:
    int value = 42;
};

struct Derived : Base {
    int read(Derived& object) {
        return object.value;
    }

    int read(Base& object) {
        return object.value;
    }
};

Если конструктор делегирует создание объекта другому конструктору того же класса, какой конструктор отвечает за инициализацию членов и что произойдёт при попытке дополнительно указать инициализаторы?

При обработке исключения сравните перехват базового типа по значению и по константной ссылке: какой вариант сохраняет полиморфизм выброшенного объекта?