C++ C++ · 25 вопросов · ~70 мин · ⏱ Таймер 10:00 · Средний ·

Исключения и noexcept

Тест проверяет, способен ли код сохранить инварианты при сбое на любом промежуточном шаге. Вопросы охватывают базовую, сильную и nothrow-гарантии, раскрутку стека, условный noexcept и ситуации, где попытка “поймать всё” только скрывает повреждение.

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

⏱ --:--

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

Вопрос 1 из 25

Что означает базовая гарантия исключений?

class Index {
    std::vector<Entry> entries_;
public:
    void rebuild(); // при ошибке объект обязан остаться корректным
};

После исключения объект может нарушить инварианты, если ресурсы не утекли Исключение автоматически подавляется, а вызывающий код получает значение по умолчанию Утечек нет и инварианты сохраняются, хотя состояние объекта могло измениться Функция не может выбросить ни при каких допустимых входных данных Операция либо завершается полностью, либо оставляет состояние бит-в-бит прежним

Вопрос 2 из 25

Что означает сильная гарантия?

auto old_state = state;
try {
    apply_update(state, request);
} catch (...) {
    // наблюдаемое состояние должно совпасть с old_state
    throw;
}

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

Вопрос 3 из 25

Как copy-and-swap помогает сильной гарантии присваивания?

Buffer& Buffer::operator=(Buffer other) {
    swap(other);
    return *this;
}

Сначала удаляются старые данные Объект меняется только после успешного создания копии Техника применима только к int swap фиксирует промежуточное состояние как транзакцию и откатывает его при любом исключении Копирование не может бросать

Вопрос 4 из 25

Какая гарантия у операции, объявленной `noexcept` и корректно реализованной без завершения программы?

void swap(Buffer& a, Buffer& b) noexcept {
    using std::swap;
    swap(a.data_, b.data_);
    swap(a.size_, b.size_);
}

static_assert(noexcept(swap(a, b)));

Базовая гарантия: инварианты сохраняются, но состояние может измениться Гарантия отсутствия исключений: исключение не покидает операцию Только гарантия освобождения ресурсов без требований к исключениям Гарантия межпоточного порядка, заданная спецификатором `noexcept` Сильная гарантия: при ошибке состояние не меняется, но исключение выходит наружу

Вопрос 5 из 25

Почему “поймать исключение, оставить половину полей новыми и вернуть false” может нарушать даже базовую гарантию?

bool Account::apply(const Change& c) {
    balance_ += c.delta;
    try {
        history_.push_back(c);
    } catch (...) {
        return false; // balance_ уже изменён
    }
    return true;
}

Связанные поля могут перестать удовлетворять инварианту Возврат bool запрещён после catch Поля нельзя менять до try Исключения не влияют на состояние Вход в catch восстанавливает значения полей, изменённых внутри try

Вопрос 6 из 25

Что произойдёт, если исключение покинет функцию, объявленную noexcept?

void flush() noexcept {
    throw std::runtime_error("disk failure");
}
// исключение не может покинуть noexcept-функцию

Исключение станет предупреждением Компилятор обязан откатить все глобальные данные Исключение проигнорируется и функция вернёт ноль После первого исключения спецификация noexcept переключается в noexcept(false) Будет вызван std::terminate

Вопрос 7 из 25

Что возвращает оператор `noexcept(expr)`?

template<class T>
constexpr bool safe_move = noexcept(T(std::declval<T&&>()));

static_assert(safe_move<std::unique_ptr<int>>);
// Само выражение-конструктор здесь не выполняется.

Константный bool, отражающий, считается ли выражение невыбрасывающим по его спецификации Значение, которое вернуло бы выражение expr при обычном выполнении Результат runtime-пробного выполнения expr без сохранения побочных эффектов Адрес обработчика, выбранного для исключения из expr Количество типов исключений, перечисленных в теле вызываемой функции

Вопрос 8 из 25

Чем заполнить пропуск, чтобы move-конструктор был noexcept только при небросающем перемещении member?

struct T {
    Member member;
    T(T&& other) /* пропуск */;
};

`noexcept(std::is_move_constructible_v<Member>)` без проверки бросающего конструктора `noexcept(false)`, чтобы контейнер всегда выбирал копирование `noexcept(noexcept(Member(std::move(other.member))))` `noexcept(noexcept(other.member))`, проверяющий лишь чтение поля `noexcept(true)`, независимо от свойств перемещения Member

Вопрос 9 из 25

Почему vector может копировать элементы вместо перемещения при росте?

struct Item {
    Item(const Item&);
    Item(Item&&); // не noexcept
};
std::vector<Item> items;
items.emplace_back(); // рост буфера

Перемещение доступно лишь для указателей Чтобы сохранить сильную гарантию при бросающем move vector не поддерживает move Копирование всегда дешевле noexcept влияет только на функции ввода

Вопрос 10 из 25

Можно ли перегружать функции только по различию noexcept?

Да, начиная с C++20 Нет, потому что noexcept не относится к типам функций Да, вызывающий выбирает try/catch Да, но различие участвует в перегрузке только у нестатических методов Нет: одной noexcept-спецификации для перегрузки мало

Вопрос 11 из 25

Что будет разрушено при выходе из f из-за исключения?

Все полностью построенные локальные объекты активных областей — в обратном порядке Все глобальные объекты разрушаются до поиска ближайшего подходящего catch Только память, полученная через new, даже если она не заключена во владеющий объект Ни один локальный объект: исключение минует все деструкторы текущей функции Лишь первый созданный объект, независимо от порядка объявления и завершения конструкторов

Вопрос 12 из 25

Почему исключения обычно ловят как `const std::exception&`?

try {
    parse_document(input);
} catch (const std::exception& error) {
    log(error.what());
    throw;
}

Так объект исключения гарантированно перемещается в стек текущей функции Catch по значению синтаксически запрещён для классов, производных от std::exception Чтобы обработчик мог изменить исходный объект исключения, хранимый средой выполнения Ссылка автоматически делает весь блок catch невыбрасывающим Ссылка сохраняет динамический тип и избегает срезки и лишней копии при вызове виртуального what()

Вопрос 13 из 25

Чем `throw;` внутри catch отличается от `throw e;`?

try {
    load_config();
} catch (const std::exception& e) {
    if (can_recover()) throw;
    throw e;
}

`throw e;` всегда сохраняет динамический тип `throw;` завершает программу `throw;` разрешён только вне catch `throw;` сохраняет объект, `throw e;` может срезать тип Они полностью одинаковы

Вопрос 14 из 25

Что произойдёт, если во время раскрутки стека деструктор выбросит второе исключение наружу?

Будет вызван `std::terminate` Среда объединит оба исключения в один exception_ptr и передаст его наружу Первое исключение будет подавлено, а второе станет единственным активным Результат определяется виртуальностью деструктора, а не наличием уже активного исключения Второе исключение заменит первое, после чего обычная раскрутка продолжится

Вопрос 15 из 25

Какую последовательность символов даст раскрутка стека перед входом в обработчик?

#include <iostream>
struct X { char c; ~X(){ std::cout << c; } };
int main(){
    try { X a{'A'}, b{'B'}; throw 1; }
    catch (...) { std::cout << "caught"; }
}

BcaughtA ABcaught caughtBA Порядок не определён BAcaught

Вопрос 16 из 25

Какой фрагмент безопаснее, если конструктор второго объекта может бросить?

Два выражения new, переданные как аргументы функции без промежуточных владельцев Два сырых указателя, которые удаляются после успешного выполнения обоих конструкторов Массив нетипизированных адресов с единой очисткой после возврата функции Глобальные указатели, чтобы они пережили исключение из локального вызова Два отдельных `std::unique_ptr`, создаваемых через make_unique до передачи дальше

Вопрос 17 из 25

Почему ручная очистка в каждом catch плохо масштабируется?

Блок catch не может вызывать освобождающие функции до повторного throw Ручная очистка корректна лишь для C API, а любой вызов из C++ catch нарушает стандарт При добавлении нового ресурса или пути ошибки легко забыть обновить одну из ветвей очистки Код очистки в catch выполняется до входа в соответствующий try RAII применим только к динамической памяти и не подходит файлам или mutex

Вопрос 18 из 25

Как безопасно использовать C API, возвращающий `FILE*`?

using File = std::unique_ptr<FILE, decltype(&std::fclose)>;

File open_file(const char* path) {
    FILE* raw = std::fopen(path, "rb");
    if (!raw) throw std::system_error(errno, std::generic_category());
    return File(raw, &std::fclose);
}

`unique_ptr<FILE, decltype(&fclose)>` Хранить FILE* в локальной переменной и закрывать его в единственной точке нормального возврата Удалять через delete Копировать структуру FILE побитово Освобождать через free

Вопрос 19 из 25

Какой порядок безопаснее для обновления файла “всё или ничего”?

Считать исключения невозможными Удалить резервную копию до начала Сначала обнулить целевой файл, затем писать по частям Писать прямо в целевой файл и откатывать отдельные изменения в catch-блоке Временный файл, успешное закрытие, атомарная замена

Вопрос 20 из 25

Что не так с `catch (...) { return; }` вокруг операции сохранения?

bool save(const Document& doc) {
    try {
        write_file(doc);
        return true;
    } catch (...) {
        return true; // вызывающий код не увидит отказ
    }
}

return внутри catch запрещён Ошибка скрыта, вызывающий код считает сохранение успешным catch (...) ловит только int Это всегда обеспечивает сильную гарантию После return среда выполнения повторно выбросит сохранённое исключение вызывающему коду

Вопрос 21 из 25

Как проверить сильную гарантию метода update?

Проверить только тип выброшенного исключения, не сравнивая состояние объекта Сравнить снимок с состоянием после исключения Убедиться, что исключение имеет короткое имя Сравнить адрес this до и после вызова и считать неизменность адреса сохранением состояния Проверить только успешный вызов

Вопрос 22 из 25

Что такое fault injection в тестах исключений?

Подмена throw на return 0 без проверки Отключение всех исключений Измерение скорости catch Принудительный throw зависимости в выбранной точке Повреждение тестового бинарного файла, чтобы загрузчик выбросил исключение

Вопрос 23 из 25

Как добавить контекст и сохранить исходную причину?

Удалить исходное исключение Заменить сообщение пустой строкой Записать только __LINE__ `std::throw_with_nested` Бросить int 1

Вопрос 24 из 25

Почему тест “функция бросила” недостаточен?

После исключения состояние объекта невозможно наблюдать даже через независимые запросы Ресурсы можно не проверять: операционная система освободит их сразу после выхода из catch Тип исключения не является частью контракта и потому проверять его вредно Нужно проверить ожидаемый тип и данные ошибки, инварианты объекта и судьбу всех ресурсов Сам факт любого throw подтверждает тип ошибки, состояние объекта и отсутствие утечек

Вопрос 25 из 25

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

Обернуть прямой вызов noexcept-функции обычным try/catch в том же процессе noexcept-исключение всегда ловится снаружи Запустить в отдельном процессе и проверить terminate Обернуть вызов обычным catch в том же процессе Сравнить sizeof функции

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

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

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

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