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

Итераторы и алгоритмы STL

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

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

⏱ --:--

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

Вопрос 1 из 20

Какой минимум требуется алгоритму `std::sort`?

std::vector<int> values{4, 1, 3, 2};
std::sort(values.begin(), values.end());
// sort использует разность и произвольное смещение итераторов

Обычные указатели на функцию Только input-итераторы Итераторы произвольного доступа Итераторы односвязного списка без дополнительных операций Только output-итераторы

Вопрос 2 из 20

Почему `std::distance` для list может быть O(n), а для vector O(1)?

std::list<int> linked(1'000'000, 1);
std::vector<int> contiguous(1'000'000, 1);

auto n1 = std::distance(linked.begin(), linked.end());
auto n2 = std::distance(contiguous.begin(), contiguous.end());

Итераторы list приходится последовательно продвигать, а random-access итераторы vector можно вычесть Перед вычислением расстояния list должен быть отсортирован по адресам узлов Сложность одинакова; различается только константа из-за выделения памяти узлов Std::distance создаёт полную копию list, но для vector использует исходный буфер Каждый итератор vector хранит общее число элементов контейнера, list — нет

Вопрос 3 из 20

Какая операция недоступна для forward-итератора?

std::forward_list<int> values{1, 2, 3, 4};
auto it = values.begin();

++it;               // допустимо
// --it;            // требуется двунаправленный итератор
// it += 2;         // требуется random access

`++it` Многократный проход по сохранённой позиции `*it` `--it` Сравнение с другим итератором диапазона

Вопрос 4 из 20

Какой пример является contiguous-итератором?

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

Вопрос 5 из 20

Почему input-итератор нельзя бездумно проходить дважды?

После достижения конца копия input-итератора обязана снова указывать на начало последовательности Input-итераторы не поддерживают разыменование После ++ программа обязана завершиться Он всегда указывает на const Он может представлять одноразовый поток, и чтение продвигает источник

Вопрос 6 из 20

Почему стандартные алгоритмы используют диапазон [first, last)?

Такой контракт нужен только встроенным массивам; контейнерные алгоритмы принимают закрытый диапазон Последний элемент считается служебным и намеренно не участвует ни в одном алгоритме Диапазон фактически закрыт с обеих сторон, а круглую скобку используют как историческое обозначение Полуоткрытая граница естественно представляет пустой диапазон и позволяет состыковывать соседние диапазоны без особых случаев Итератор last нельзя сравнивать с first, поэтому его используют лишь как числовую длину

Вопрос 7 из 20

Что делает `std::remove(v.begin(), v.end(), 0)`?

std::vector<int> values{0, 1, 0, 2};
auto logical_end = std::remove(values.begin(), values.end(), 0);

std::cout << std::distance(values.begin(), logical_end)
          << ' ' << values.size();

Сортирует элементы так, чтобы все нули оказались в конце диапазона Переставляет сохраняемые элементы к началу и возвращает итератор новой логической границы Находит и удаляет только первое совпадение, оставляя остальные позиции без изменений Удаляет элементы из vector и немедленно меняет его size Возвращает количество совпадений, не перемещая ни одного элемента

Вопрос 8 из 20

Какой результат будет в out?

#include <algorithm>
#include <vector>
std::vector<int> in{1,2,3};
std::vector<int> out(3);
std::transform(in.begin(), in.end(), out.begin(), [](int x){ return x*x; });

`{1, 4, 9}` `{2, 4, 6}` Код не компилируется `{0, 0, 0}` `{1, 2, 3}`

Вопрос 9 из 20

Какой начальный аккумулятор нужен, чтобы `std::accumulate` не обрезал дробную сумму?

std::vector<double> values{0.1, 0.2, 0.3};

auto truncated = std::accumulate(values.begin(), values.end(), 0);
auto precise   = std::accumulate(values.begin(), values.end(), 0.0);

`false` `nullptr` `0.0` Начальное значение не влияет на тип результата `0`

Вопрос 10 из 20

Какой алгоритм яснее ручного цикла для проверки “все числа положительны”?

std::vector<int> values{3, 5, 8, 13};

bool all_positive = std::ranges::all_of(values, [](int x) {
    return x > 0;
});

`std::shuffle` `std::merge` `std::all_of` `std::partition_copy` `std::rotate`

Вопрос 11 из 20

Почему компаратор `return a <= b;` неверен для std::sort?

std::vector<int> values{2, 1, 1};

std::sort(values.begin(), values.end(), [](int a, int b) {
    return a <= b;
});

sort принимает только function pointer <= слишком медленный Компаратор обязан возвращать int `<=` истинно для равных и нарушает строгий порядок Равные элементы запрещены в vector

Вопрос 12 из 20

Может ли предикат, переданный в std::find_if, изменять проверяемый элемент через свой параметр?

Да, если контейнер не является const и предикат возвращает bool Нет: предикат должен проверять элемент, не изменяя его через переданный аргумент Ограничение относится только к предикатам сортировки; `find_if` разрешает менять элемент, если итератор неконстантный Да, но только после того, как подходящий элемент уже найден Да, если изменение не меняет размер контейнера

Вопрос 13 из 20

Что найдёт выражение?

int limit = 3;
auto it = std::find_if(v.begin(), v.end(), [limit](int x){ return x > limit; });

Элемент с индексом, численно равным значению `limit` Ничего: захват локальной переменной по значению здесь запрещён Первый элемент больше `limit`, причём в примере `limit` равен 3 Последний элемент диапазона, удовлетворяющий условию предиката Сам объект `limit`, независимо от содержимого диапазона

Вопрос 14 из 20

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

Порядок может измениться во время сортировки Риск только в размере бинарника Глобальные переменные всегда const Контейнер создаёт снимок элементов перед сортировкой, поэтому изменения глобального состояния не влияют на порядок Компаратор перестанет компилироваться

Вопрос 15 из 20

Какой захват нужен, если лямбда должна увеличивать внешний счётчик?

int count = 0;
std::vector<int> values{1, -2, 3, -4};

std::ranges::for_each(values, [&count](int x) {
    if (x < 0) ++count;
});

Захват `[&count]`, чтобы инкрементировать именно внешний счётчик Захват `[this]`, даже если `count` является обычной локальной переменной Захват `[=]`: запись в копию всегда меняет исходную переменную Захват `[count]`: изменение копии без `mutable` обновит внешний счётчик Пустой захват `[]`, поскольку локальные переменные доступны из тела лямбды

Вопрос 16 из 20

Как безопасно удалять элементы vector по условию во время прохода?

`std::erase_if` либо присваивание результата `erase` Делать ++it после erase(it), продолжая использовать старый it Удалять элементы через delete &*it Вызывать clear внутри цикла Хранить все итераторы навсегда

Вопрос 17 из 20

Что инвалидирует vector::push_back, если операция приводит к перераспределению буфера?

Только обычные итераторы; ссылки и указатели остаются действительными Все итераторы, ссылки и указатели на элементы vector Только end(), потому что существующие элементы сохраняют адреса Только итераторы на последний элемент и end() Ничего, если тип элемента имеет noexcept-конструктор перемещения

Вопрос 18 из 20

Инвалидирует ли вставка в std::map существующие итераторы?

Итераторы map всегда одноразовые Только begin Да, все Только если ключ больше максимального Нет, обычная вставка не инвалидирует их

Вопрос 19 из 20

Что может инвалидировать итераторы unordered_map?

Чтение элемента через константную ссылку на его значение Изменение значения по уже существующему ключу без вставки `rehash`, в том числе вызванный вставкой при росте таблицы Получение текущего размера контейнера через `size()` Поиск существующего ключа с помощью `contains` или `find`

Вопрос 20 из 20

Почему этот цикл ошибочен?

for (auto it = v.begin(); it != v.end(); ++it) {
    if (*it == 0) v.erase(it);
}

Условие должно быть x < 0 vector нельзя изменять в цикле `erase` инвалидирует it, после чего выполняется ++it Цикл обязан использовать индекс int erase нельзя вызывать у vector

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

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

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

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