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

Лямбда-выражения

Тест разбирает объект замыкания как обычный объект с полями и временем жизни. Вопросы проверяют захват по значению и ссылке, mutable, обобщённые параметры, рекурсию и особенно опасные callback, которые переживают локальные переменные или сам объект.

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

⏱ --:--

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

Вопрос 1 из 25

Какое значение вернёт лямбда после изменения x, если x захвачен по значению?

#include <iostream>
int main(){
    int x = 5;
    auto f = [x]{ return x; };
    x = 8;
    std::cout << f();
}

3 Поведение не определено 5 8 Код не компилируется

Вопрос 2 из 25

Какое значение вернёт лямбда после изменения x, если x захвачен по ссылке?

#include <iostream>
int main(){
    int x = 5;
    auto f = [&x]{ return x; };
    x = 8;
    std::cout << f();
}

8 Код не компилируется Поведение не определено 5 13

Вопрос 3 из 25

Зачем нужен init-capture `[p = std::move(ptr)]`?

auto socket = std::make_unique<Socket>(connect());

auto task = [s = std::move(socket)]() mutable {
    s->send("ping");
    s.reset();
};

queue.push(std::move(task));

Чтобы p стал глобальным Чтобы переместить move-only объект в поле замыкания Чтобы захватить ptr по ссылке Чтобы после первого вызова лямбды unique_ptr неявно выполнил release вместо обычного разрушения Чтобы скопировать unique_ptr

Вопрос 4 из 25

Что именно захватывает `[this]`?

class Counter {
public:
    auto callback() {
        return [this] { ++value_; };
    }
private:
    int value_ = 0;
};

Все поля как независимые копии Ссылку на объект с тем же временем жизни, что и сохранённая лямбда Только public-поля Указатель this, а не копию всего объекта shared_ptr на объект

Вопрос 5 из 25

Как захватить копию самого объекта в C++17?

class Snapshot {
public:
    auto printer() const {
        return [*this] { std::cout << value_; };
    }
private:
    int value_ = 42;
};

`[this]` `[*this]` `[object]` без переменной `[=this]` `[&this]`

Вопрос 6 из 25

Почему без mutable нельзя увеличить x, захваченный по значению?

Захват по значению делает локальную переменную глобальной константой `mutable` требуется для любого тела лямбды, содержащего `return` Операция инкремента для int внутри лямбд запрещена языком `operator()` у замыкания по умолчанию `const`, а захваченный x является его полем Лямбда-выражения не могут хранить собственное изменяемое состояние

Вопрос 7 из 25

Какое число выведет второй вызов mutable-лямбды?

#include <iostream>
int main(){
    int x = 10;
    auto next = [x]() mutable { return ++x; };
    next();
    std::cout << next();
}

11 22 12 Поведение не определено Код не компилируется

Вопрос 8 из 25

Меняет ли mutable внешнюю переменную при захвате по значению?

Поведение не определено Внешняя переменная уничтожается Нет, меняется только поле объекта замыкания Да, если захваченная переменная имеет арифметический тип и лямбда объявлена mutable Да, mutable превращает захват в ссылку

Вопрос 9 из 25

Нужно ли mutable, чтобы менять объект через захваченный указатель?

Нет, меняется объект, а не значение указателя Только если объект const Только для nullptr Нет, потому что указатель копируется глубоко Да, любое изменение через лямбду требует mutable

Вопрос 10 из 25

Какой риск у stateful mutable-лямбды, вызываемой из нескольких потоков?

Гонка данных на её внутренних полях, если вызовы не синхронизированы mutable делает внутреннее состояние лямбды атомарным и сериализует вызовы Лямбды нельзя передавать между потоками Риск только при захвате this Каждый вызов получает независимую копию состояния

Вопрос 11 из 25

Что означает параметр `auto x` у лямбды?

auto stringify = [](auto x) {
    using T = decltype(x);
    return std::to_string(static_cast<T>(x));
};

stringify(7);
stringify(3.5);

Замыкание имеет шаблонный `operator()`, параметр которого выводится и передаётся по значению Тип x выбирается во время выполнения и хранится внутри variant Auto разрешён только у возвращаемого типа лямбды, но не в списке параметров Наличие auto превращает лямбду в обычный указатель на перегруженную функцию При каждом вызове x сначала преобразуется к int, потому что auto у параметра означает целое значение

Вопрос 12 из 25

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

auto forward_call = [](auto&& value, auto&& fn) -> decltype(auto) {
    return std::forward<decltype(fn)>(fn)(
        std::forward<decltype(value)>(value));
};

`auto& x` для lvalue и отдельная перегрузка лямбды для rvalue `auto&& x` и `std::forward<decltype(x)>(x)` `const auto& x` и безусловный `std::move(x)` `auto* x` с восстановлением исходной категории по адресу `auto x` и безусловный `std::move(x)` при передаче дальше

Вопрос 13 из 25

Что даёт синтаксис C++20 `[ ]<class T>(T value) { ... }`?

auto first = []<class T, std::size_t N>(const std::array<T, N>& values)
    -> const T& {
    static_assert(N > 0);
    return values.front();
};

Препроцессорный параметр T, подставляемый до разбора лямбды Явный список шаблонных параметров для `operator()` замыкания Захват runtime-типа T из окружающей области вместе с остальными переменными Объявление виртуального оператора вызова с параметром T Определение локального шаблона класса, экземпляр которого является замыканием

Вопрос 14 из 25

Почему разные вызовы generic-лямбды могут генерировать разные тела?

Для каждого набора выведенных типов инстанцируется соответствующий `operator()` Тело лямбды интерпретируется заново при каждом вызове на основании RTTI аргументов Разные тела появляются лишь при наличии виртуальных функций у типов аргументов Компилятор создаёт одно нетипизированное тело и выбирает операции по RTTI при каждом вызове Линковщик после сборки создаёт специализации по журналу фактических runtime-вызовов

Вопрос 15 из 25

Что произойдёт с return-типом?

auto twice = [](auto x) { return x + x; };

Тип определяется первым runtime-вызовом return запрещён в generic lambda Тип вывода определяется отдельно для каждого T Все вызовы обязаны возвращать один глобальный тип auto всегда означает int

Вопрос 16 из 25

Почему возвращённая лямбда опасна?

auto make(){
    int x = 42;
    return [&]{ return x; };
}

Внутри остаётся ссылка на уничтоженную x Лямбды нельзя возвращать Опасность только при x == 0 Ссылка превращается в копию Компилятор переносит захваченную по ссылке локальную переменную в heap вместе с closure

Вопрос 17 из 25

Как безопаснее передать локальные данные в задачу, которая выполнится позже?

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

Вопрос 18 из 25

Какой шаблон безопасен для callback объекта под shared_ptr?

Создать новый shared_ptr(this) Захватить weak_ptr и вызвать lock внутри Хранить ссылку на локальный shared_ptr Захватить this и считать объект вечным Вызвать delete this при ошибке

Вопрос 19 из 25

Продлевает ли `[&obj]` жизнь obj?

std::function<void()> make_callback() {
    Widget object;
    return [&object] {
        object.refresh();
    };
}

auto callback = make_callback();
callback();

Только если лямбда mutable Нет Да, до разрушения лямбды Только в std::function Только если obj const

Вопрос 20 из 25

Почему копия `[*this]` может быть логически устаревшей?

class Model {
public:
    auto deferred_snapshot() const {
        return [*this] { return state_; };
    }
    void update(State s) { state_ = std::move(s); }
private:
    State state_;
};

Копирование this запрещено Callback видит старый снимок полей Копия объекта получает последующие изменения оригинала при каждом вызове closure Снимок обновляется при каждом вызове Она всегда ссылается на оригинал

Вопрос 21 из 25

Почему лямбда с захваченным unique_ptr не помещалась в std::function до поддержки move-only обёрток?

`std::function` принимает лишь свободные функции и отклоняет любые замыкания Тип замыкания становится move-only, тогда как `std::function` требует копируемый хранимый callable Язык запрещает init-capture для unique_ptr, даже если лямбду не копируют Захваченное владение требует копируемого operator(), даже если само замыкание перемещаемо `std::function` хранит только машинный адрес функции и не умеет хранить состояние

Вопрос 22 из 25

Как AddressSanitizer поможет с callback, захватившим ссылку на локальную переменную?

Меняет захват по ссылке на захват по значению во время инструментирования Продлевает время жизни захваченной локальной переменной до удаления callback Переписывает тело лямбды и добавляет безопасную проверку срока жизни Не проверяет стек и способен находить только ошибки в динамической памяти Может обнаружить `stack-use-after-scope` при позднем вызове callback

Вопрос 23 из 25

Как написать рекурсивную лямбду без std::function в C++20?

auto fact = [](auto&& self, int n) -> int {
    return n < 2 ? 1 : n * self(self, n - 1);
};

Обратиться к переменной с лямбдой из её тела до завершения объявления Нельзя: без `std::function` рекурсия в лямбдах запрещена Использовать `goto` для перехода к началу тела лямбды Передавать саму лямбду дополнительным параметром `auto&& self` Сделать `operator()` виртуальным и вызвать его через базовый класс

Вопрос 24 из 25

Какой тест выявит, что mutable-лямбда была неожиданно скопирована?

Проверить sizeof(int) Вызвать только один объект Сравнить внутренние счётчики оригинала и копии Сделать все захваты ссылочными Сравнить только адрес функции

Вопрос 25 из 25

Почему `[=]` не всегда хороший выбор по умолчанию?

class Session {
public:
    auto handler() {
        return [=](Request request) {
            log(id_, request); // захват this, а не копии Session
        };
    }
private:
    int id_ = 0;
};

Он делает все поля static Он запрещён стандартом Захват по значению сам по себе создаёт data race при любом многопоточном вызове Скрывает состав и стоимость захвата Он захватывает глобальные переменные

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

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

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

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