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

optional, variant и any

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

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

⏱ --:--

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

Вопрос 1 из 25

Что выражает `std::optional<int>` лучше обычного int с -1 как sentinel?

std::optional<int> find_index(std::string_view name);

if (auto index = find_index("root")) {
    use(*index);            // 0 — допустимый найденный индекс
} else {
    report_not_found();
}

Явно отделяет отсутствие от любого int, включая -1 Он хранит только положительные числа optional всегда быстрее int Он исключает все ошибки optional проверяет допустимый диапазон int при каждом присваивании и отвергает -1

Вопрос 2 из 25

Что произойдёт при вызове `opt.value()` у пустого optional?

std::optional<int> value;

try {
    std::cout << value.value();
} catch (const std::bad_optional_access& error) {
    std::cerr << error.what();
}

Будет возвращена ссылка на несуществующее значение, что даст неопределённое поведение Вернётся `T{}` без изменения самого optional Вызов не компилируется для любого optional, потому что доступ разрешён только через `operator*` Optional сначала создаст значение `T{}`, сохранит его и вернёт ссылку Будет выброшено `std::bad_optional_access`

Вопрос 3 из 25

Что выведет value_or(7) для пустого optional<int>?

#include <iostream>
#include <optional>
int main(){
    std::optional<int> x;
    std::cout << x.value_or(7);
}

0 7 Код не компилируется Будет исключение 42

Вопрос 4 из 25

Почему `std::optional<T&>` отсутствует в стандартном optional?

int value = 42;
// std::optional<int&> ref = value; // такой специализации нет

std::optional<std::reference_wrapper<int>> ref = std::ref(value);
ref->get() = 7;

Любая C++-ссылка уже содержит встроенное пустое состояние, поэтому optional был бы избыточен Неясно, должно ли присваивание перепривязывать ссылку или присваивать значение исходному объекту Optional поддерживает только арифметические и перечислимые типы Ссылочный тип нельзя использовать параметром ни одного стандартного шаблона Ссылка увеличила бы размер optional сильнее, чем любое объектное значение T

Вопрос 5 из 25

Когда `optional<optional<T>>` может быть осмыслен?

enum class FieldState { Missing, Null, Value };

struct ParsedField {
    FieldState state;
    std::optional<std::optional<int>> value;
};
// outer nullopt: поле отсутствует; inner nullopt: явный null

Чтобы optional стал variant Никогда, вложенные шаблоны запрещены Только для ускорения доступа Когда T не копируется Для трёх состояний: не задано, очищено, есть T

Вопрос 6 из 25

Главное отличие variant от any?

using Payload = std::variant<Text, Image, Error>;
Payload payload = Image{/*...*/};
std::visit(Visitor{}, payload);

variant хранит только один конкретный тип навсегда any не хранит значения Набор допустимых типов variant фиксирован в типе на этапе компиляции any предоставляет встроенный visit по закрытому набору типов, определяемому при первом присваивании variant всегда выделяет память в куче

Вопрос 7 из 25

Что показывает `v.index()`?

using Value = std::variant<int, std::string, Error>;
Value value = std::string("ok");

std::cout << value.index();
// Индекс связан с порядком альтернатив в объявлении типа.

Число копий variant Номер текущей альтернативы Количество всех альтернатив плюс один Размер хранимого объекта Адрес контрольного блока

Вопрос 8 из 25

Зачем добавляют `std::monostate` первой альтернативой?

using Result = std::variant<std::monostate, Success, Failure>;

Result result; // корректно создаётся в первом, “пустом” состоянии
if (std::holds_alternative<std::monostate>(result))
    start_request();

Чтобы variant получил интерфейс optional с `has_value()` и `value()` Чтобы дать variant нейтральную первую альтернативу и возможность default-конструирования Чтобы запретить вызов visitor, пока не выбрана содержательная альтернатива Чтобы при default-конструировании удалить из списка все остальные альтернативы Чтобы зарезервировать место исключительно для строкового значения

Вопрос 9 из 25

В какой ситуации `std::variant` может перейти в состояние `valueless_by_exception`?

`std::get<T>` запросил неактивную альтернативу и выбросил `std::bad_variant_access` Из активного значения выполнили перемещение, поэтому исходный `variant` всегда теряет саму альтернативу Первая альтернатива не имеет конструктора по умолчанию, поэтому `variant` сначала создаётся без активного значения Вызов `index()` вернул `variant_npos`; именно это чтение перевело объект в пустое состояние Во время операции, меняющей активную альтернативу, если построение новой альтернативы завершилось исключением и сохранить прежнее значение не удалось

Вопрос 10 из 25

Что не так с `std::variant<int, int>`?

std::variant<int, int> value(std::in_place_index<0>, 7);

// std::get<int>(value); // тип встречается дважды — обращение по типу неоднозначно
std::cout << std::get<0>(value);

Такой variant не компилируется вообще Хранит сразу два числа Оба int объединяются в один Он всегда valueless Доступ `get<int>` неоднозначен; нужен индекс

Вопрос 11 из 25

Что делает std::visit?

Последовательно вызывает visitor для каждой объявленной альтернативы Стирает тип активного значения до нетипизированного указателя Возвращает только индекс активной альтернативы, не вызывая пользовательский код Перед вызовом всегда копирует активное значение, даже если visitor принимает ссылку Вызывает visitor с активной альтернативой одного или нескольких variant

Вопрос 12 из 25

Почему generic-visitor `[](const auto& x){ ... }` должен компилироваться для всех альтернатив?

using Event = std::variant<Opened, Data, Closed>;

std::visit([](const auto& event) {
    // Тело инстанцируется для Opened, Data и Closed.
    log(event.timestamp());
}, current_event);

Visitor проверяется лишь для первой альтернативы, остальные инстанцируются при runtime-выборе `std::visit` должен уметь сформировать корректный вызов для каждой возможной альтернативы Полная проверка выполняется только при наличии отладочной информации Все альтернативы variant обязаны наследоваться от общего базового класса visitor Тип параметра auto выбирается по typeid во время выполнения

Вопрос 13 из 25

Как собрать visitor из нескольких лямбд-перегрузок?

Привести одну лямбду к типу другой и заменить её operator() Создать тип `overloaded`, наследующийся от лямбд и раскрывающий их `operator()` через using Объединить замыкания оператором `+`, получив один callable с несколькими сигнатурами Вызвать visit по одному разу на каждую лямбду и выбрать успешный результат Сохранить адреса замыканий в контейнере нетипизированных указателей

Вопрос 14 из 25

Какое требование std::visit предъявляет к результатам вызова visitor для всех сочетаний альтернатив?

Результаты могут иметь любые типы, если каждый неявно приводится к bool Требование действует только для visitor без состояния Достаточно, чтобы размеры возвращаемых объектов совпадали Все вызовы должны иметь один и тот же тип результата и категорию значения Разные типы допустимы, если variant содержит не больше двух альтернатив

Вопрос 15 из 25

Как обработать добавление новой альтернативы так, чтобы компилятор помог?

Проверять только index == 0 Всегда использовать `[](auto&&){}` без действий Преобразовать variant в any Игнорировать новую альтернативу Избегать общего catch-all или ставить static_assert

Вопрос 16 из 25

Что произойдёт при `std::any_cast<int>(a)`, если a хранит std::string?

std::any value = std::string("42");

try {
    std::cout << std::any_cast<int>(value);
} catch (const std::bad_any_cast& error) {
    std::cerr << error.what();
}

Поведение не определено Вернётся 0 Будет выброшено std::bad_any_cast a начнёт хранить int Строка преобразуется через stoi

Вопрос 17 из 25

Как проверить any без исключения?

Сравнить sizeof(a) и sizeof(T), считая одинаковый размер признаком совпадения типа Сравнить sizeof(a) с sizeof(T) Проверить только a.has_value(), после чего выполнить any_cast<T>(a) Указательный `any_cast`, возвращающий nullptr Сравнить строку a.type().name() с ожидаемым именем типа, а затем выполнить обычный any_cast

Вопрос 18 из 25

Что означает `a.has_value()`?

std::any payload;
std::cout << payload.has_value();

payload = 42;
std::cout << payload.has_value();

payload.reset();
std::cout << payload.has_value();

Тип значения равен int Значение логически истинно any можно копировать только один раз Память выделена в куче any сейчас хранит некоторое значение

Вопрос 19 из 25

Как узнать std::type_info хранимого значения?

std::any payload = std::vector<int>{1, 2, 3};

if (payload.has_value()) {
    const std::type_info& type = payload.type();
    std::cout << type.name();
}

`a.index()` `a.dynamic_type<T>()` `a.value_type()` `typeid(std::any)` `a.type()`

Вопрос 20 из 25

Почему any может быть плохим полем основной бизнес-сущности?

any нельзя хранить в классе Он поддерживает только POD Он не имеет деструктора Допустимые состояния не видны компилятору Он всегда занимает гигабайт

Вопрос 21 из 25

Какой тип результата яснее для “либо значение, либо подробная ошибка”?

std::expected<Config, ParseError> parse_config(std::string_view text);

auto result = parse_config(input);
if (!result)
    return report(result.error());
return start(*result);

Сырой указатель `T*` и глобальная переменная с последней ошибкой `std::any`, оставляя вызывающему коду угадывание фактического типа `bool`, который сообщает только успех, но не возвращает значение `std::optional<T>`, если подробную причину ошибки хранить негде `std::expected<T, Error>` в C++23 или аналогичный тип результата

Вопрос 22 из 25

Как протестировать visitor variant?

Проверить лишь `variant::index()`, не проверяя обработку значения Запустить один и тот же набор ожидаемых сценариев для каждой альтернативы и проверить общий результат visitor Проверить только первую альтернативу, поскольку остальные используют то же тело шаблона Сравнить sizeof visitor для разных сборок, не вызывая его Не создавать variant напрямую, а считать успешную компиляцию достаточной

Вопрос 23 из 25

Что стоит проверить у optional-returning поиска?

Только скорость value() Только копируемость optional Успех, отсутствие и граничные значения Только размер int Только пустой контейнер

Вопрос 24 из 25

Какой тест выявит неправильный any_cast?

Другой C++-тип и ожидаемый отказ Ожидать bad_variant_access вместо bad_any_cast при несовпадении типа Всегда класть и извлекать один int Перед приведением проверить только has_value(), не проверяя фактический тип содержимого Проверять приведение лишь после копирования any в const-объект того же типа

Вопрос 25 из 25

Почему property-тест полезен для переходов variant-состояний?

Они заменяют компилятор Переходы нельзя генерировать Property-тесты работают только с числами Variant сам доказывает правила переходов Генерирует длинные переходы и проверяет инвариант

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

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

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

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