C++ C++ · 20 вопросов · ~55 мин · ⏱ Таймер 55:00 · Лёгкий ·

Копирование и перемещение

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

Отвечено: 0 из 20

⏱ --:--

💡 Инструкция: Выберите один ответ из пяти. В тесте 20 вопросов, время — 55 минут. Во многих заданиях недостаточно узнать конструкцию: проследите порядок вычислений, время жизни объектов, владение ресурсами и условия, при которых решение остаётся корректным. После завершения откроются правильные ответы, объяснения, общий результат и тематические шкалы.

Вопрос 1 из 20

Какая сигнатура является обычным конструктором копирования?

class Buffer {
public:
    Buffer(const Buffer& other);
    Buffer(Buffer&& other) noexcept;
    Buffer& operator=(const Buffer& other);
private:
    std::unique_ptr<std::byte[]> data_;
};

`T& operator=(const T&)` `T(T*)` `T(T&&)` `void T(const T&)` `T(const T&)`

Вопрос 2 из 20

Почему побитовое копирование класса с владеющим `char*` опасно?

struct Text {
    char* data;
    std::size_t size;
};

Text a{duplicate("hello"), 5};
Text b = a;           // копируются только адрес и size
delete[] a.data;
std::cout << b.data;

Опасность только при длине строки больше 255 Копия указателя всегда становится nullptr Копирование указателя создаёт независимый буфер, если поле находится в классе с деструктором Указатели нельзя копировать процессором Две копии будут владеть одним адресом и могут дважды его освободить

Вопрос 3 из 20

Что произойдёт при передаче Derived по значению в функцию, принимающую Base?

struct Base { virtual ~Base() = default; };
struct Derived : Base { int extra = 7; };
void use(Base value);
Derived d;
use(d);

Передача запрещена, если Base полиморфный; компилятор потребует параметр-ссылку В параметр Base скопируется только базовая часть, то есть произойдёт срезка Базовая и производная части будут раздельно скопированы в два объекта с общим временем жизни Виртуальные методы заставят параметр Base сохранить внутри себя всю производную часть Параметр по значению неявно станет ссылкой на исходный Derived, чтобы избежать копии

Вопрос 4 из 20

Как запретить копирование объекта?

class Socket {
public:
    Socket(const Socket&) = delete;
    Socket& operator=(const Socket&) = delete;
    Socket(Socket&&) noexcept = default;
    Socket& operator=(Socket&&) noexcept = default;
};

Удалить конструктор по умолчанию Сделать деструктор public Пометить поля mutable Удалить copy-конструктор и copy-присваивание Добавить explicit к каждому методу

Вопрос 5 из 20

Когда передача большого объекта по const-ссылке обычно лучше передачи по значению?

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

Вопрос 6 из 20

Что на самом деле делает `std::move(x)`?

std::string source = "payload";
std::string&& ref = std::move(source);

// До вызова конструктора или присваивания данные не переносились.
std::string target(std::move(ref));

Преобразует x в xvalue Физически перемещает байты x Уничтожает x Создаёт поток для перемещения Гарантированно очищает все поля x

Вопрос 7 из 20

Почему перемещение из `const T` часто превращается в копирование?

struct Item {
    Item(const Item&);
    Item(Item&&) noexcept;
};

const Item source;
Item target = std::move(source);

move-конструктор T&& не может менять const-источник const-объекты нельзя передавать в функции std::move удаляет const у выражения, поэтому выбирается T&& Перемещающий конструктор рассматривается только для типов, содержащих сырой указатель Копирование всегда быстрее

Вопрос 8 из 20

Какое состояние должен иметь источник после корректного перемещения?

Действительное, но с неуточнённым значением Он обязан сохранять прежнее значение Источник обязан перейти в состояние объекта другого служебного типа moved_from Его запрещено даже разрушать Стандарт всегда требует полного обнуления всех полей

Вопрос 9 из 20

Почему перемещающий конструктор пользовательского типа желательно объявлять `noexcept`, если он действительно не бросает исключений?

Без `noexcept` стандарт запрещает вызывать перемещающий конструктор, поэтому программа не проходит компиляцию `noexcept` делает перенос ресурса атомарной операцией и тем самым устраняет гонки данных между потоками `std::vector` сможет перемещать элементы такого типа при перераспределении, не ослабляя сильную гарантию исключений `noexcept` нужен, чтобы RTTI сохранил динамический тип объекта после перемещения ресурса в новое хранилище `noexcept` заставляет компилятор сгенерировать перемещающий конструктор вместо копирующего, даже если он не объявлен

Вопрос 10 из 20

Какой конструктор A сработает при создании b из std::move(a)?

#include <iostream>
#include <utility>
struct A {
    A() = default;
    A(const A&) { std::cout << "copy"; }
    A(A&&) noexcept { std::cout << "move"; }
};
int main(){ A a; A b(std::move(a)); }

Код не компилируется Выбор не определён move copy copymove

Вопрос 11 из 20

Какие функции входят в правило пяти?

Деструктор, два конструктора переноса состояния и одна общая операция присваивания Конструктор по умолчанию и четыре арифметических оператора Деструктор, две copy- и две move-операции Конструктор по умолчанию, копирующий и перемещающий конструкторы, а также обе операции присваивания Деструктор и четыре виртуальные функции

Вопрос 12 из 20

Что означает правило нуля?

Объект всегда должен инициализироваться нулём Все специальные функции нужно удалить Не писать special members, полагаясь на RAII-поля Класс не должен иметь полей Запрещено использовать наследование

Вопрос 13 из 20

Как пользовательский деструктор может повлиять на неявное перемещение?

Пользовательский деструктор подавляет неявные move-операции Он превращает класс в abstract Он заставляет компилятор перемещать все поля побитово Никак не влияет ни при каких условиях Он удаляет copy-конструктор во всех стандартах

Вопрос 14 из 20

Какую технику часто используют для безопасного copy-присваивания владеющего типа?

Copy-and-swap: сначала построить независимую копию, затем обменять состояния Сначала безусловно освободить текущее состояние, а затем начать операции, которые могут выбросить Перенести байтовое представление правой части в левую через memcpy независимо от типа ресурса Скопировать адрес ресурса и оставить обеим копиям одинаковую обязанность освобождения Явно вызвать деструктор для `*this`, после чего записывать в уже завершивший жизнь объект

Вопрос 15 из 20

Какое объявление уместно для типа, который можно только перемещать?

Перевести ресурсные поля в открытую часть класса и поручить вызывающему коду избегать самоприсваивания Запретить конструктор по умолчанию, оставив копирование Удалить copy-операции и оставить/объявить move-операции Добавить виртуальный copy-конструктор Перед выполнением тела перемещающий оператор неявно сравнивает адреса this и other

Вопрос 16 из 20

Можно ли присвоить новое значение строке после перемещения из неё?

Только в том же полном выражении, где выполнялось перемещение Только после повторного начала времени жизни через placement new Нет: любое обращение к перемещённому объекту имеет неопределённое поведение Да: объект остаётся действительным, и ему можно присвоить новое значение Только если реализация гарантирует, что строка стала пустой

Вопрос 17 из 20

Какое утверждение о `source.empty()` сразу после `target = std::move(source)` переносимо?

std::string source = read_text();
std::string target = std::move(source);

// Какое из утверждений о source переносимо?
log(source.size());
source = "reused";

Перемещение копирует source в target и не меняет source Пустота не гарантирована без явного контракта source всегда сохраняет исходное значение Вызов empty запрещён source всегда пуст по стандарту для любого типа

Вопрос 18 из 20

Почему присваивание `x = std::move(x)` стоит учитывать в пользовательском move-операторе?

Buffer& Buffer::operator=(Buffer&& other) noexcept {
    if (this == &other) return *this;
    release();
    data_ = std::exchange(other.data_, nullptr);
    size_ = std::exchange(other.size_, 0);
    return *this;
}

buffer = std::move(buffer);

При совпадении адресов выбирается копирующее присваивание вместо перемещающего При self-move стандарт восстанавливает исходное значение объекта после завершения оператора Проверка нужна только для арифметических полей, которые могут обнулиться при обмене Самоперемещение невозможно, потому что std::move создаёт отдельный временный объект Самоперемещение может возникнуть в обобщённом коде; оператор должен оставить объект действительным

Вопрос 19 из 20

Какой код безопаснее после передачи unique_ptr?

auto p = std::make_unique<int>(9);
auto q = std::move(p);

Вызвать delete p.get() Считать, что p владеет копией Сравнить содержимое *p без проверки Не разыменовывать p: после перемещения он пуст Разыменовать p, потому что адрес сохранён

Вопрос 20 из 20

Зачем пользовательскому типу определить ясное moved-from состояние, если это дёшево?

Чтобы объект после перемещения можно было безопасно разрушить, присвоить ему новое значение и понятнее диагностировать ошибки Чтобы запретить любое последующее присваивание moved-from объекту Чтобы moved-from объект можно было уничтожить только специальной функцией, а не обычным деструктором Чтобы `std::move` начал физически копировать память вместо приведения категории значения Чтобы компилятор разрешил копирование даже при удалённом copy-конструкторе

Ответьте на все 20 вопросов, чтобы получить результат

🔗 Встроить тест на свой сайт (iframe) ▼

Скопируйте код и вставьте в любое место на вашем сайте:

Также доступна прямая ссылка на embed-страницу