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

Ranges и представления

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

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

⏱ --:--

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

Вопрос 1 из 25

Что требуется от типа, чтобы он удовлетворял `std::ranges::range`?

template<std::ranges::range R>
void print(R&& range) {
    auto first = std::ranges::begin(range);
    auto last = std::ranges::end(range);
    for (; first != last; ++first) std::cout << *first;
}

Чтобы элементы лежали непрерывно `ranges::begin/end(r)` должны образовывать диапазон Чтобы тип наследовался от std::vector Чтобы диапазон владел элементами Чтобы size() выполнялся за O(1)

Вопрос 2 из 25

Чем sentinel отличается от итератора конца в классическом STL?

struct null_sentinel {};
struct c_string_iterator {
    const char* p;
    char operator*() const { return *p; }
    c_string_iterator& operator++() { ++p; return *this; }
};
bool operator==(c_string_iterator it, null_sentinel) {
    return *it.p == '\0';
}

Различий нет: стандарт требует одинаковый тип начала и конца Sentinel обязан быть итератором, указывающим на последний элемент диапазона Sentinel хранит размер контейнера и не участвует в сравнении Он может иметь другой тип и должен уметь сравниваться с итератором Sentinel всегда представлен нулевым указателем независимо от диапазона

Вопрос 3 из 25

Что даёт `std::ranges::sort(v, {}, &Person::age)`?

struct Person { std::string name; int age; };
std::ranges::sort(people, {}, &Person::age);

Сортирует элементы по `Person::age`, используя указатель на член как проекцию Сортирует адреса объектов Person, не обращаясь к их полям Проекция на поле разрешена только для статических членов класса Строит отдельный vector возрастов и оставляет исходный диапазон без изменений Удаляет элементы, для которых поле age отсутствует или равно нулю

Вопрос 4 из 25

Почему ranges-алгоритм часто удобнее классического аналога?

auto first_long_name = std::ranges::find_if(
    users,
    [](std::string_view name) { return name.size() > 20; },
    &User::name
);

Он принимает только встроенные массивы и не работает с контейнерами Алгоритм автоматически запускается в отдельном потоке Любой ranges-алгоритм имеет лучшую асимптотику, чем классический аналог Алгоритм принимает диапазон целиком, поддерживает projection и ограничивает интерфейс concepts Ranges полностью отказались от итераторов и используют индексы

Вопрос 5 из 25

Что означает `std::ranges::sized_range<R>`?

template<std::ranges::sized_range R>
void reserve_for(const R& source, std::vector<Value>& out) {
    out.reserve(std::ranges::size(source));
}

reserve_for(std::array{1,2,3}, output);

Диапазон обязательно является vector `ranges::size` доступен за амортизированное O(1) Все элементы имеют одинаковый sizeof Размер известен только линковщику В диапазоне ровно один элемент

Вопрос 6 из 25

Какое свойство типично для view?

auto adults = people
    | std::views::filter([](const Person& p) { return p.age >= 18; })
    | std::views::transform(&Person::name);

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

Вопрос 7 из 25

Материализует ли `v | std::views::transform(f)` новый vector результатов?

std::vector<int> values{1,2,3};
auto doubled = values | std::views::transform([](int x) {
    std::cout << "transform ";
    return x * 2;
});

// Преобразование выполняется при обходе doubled, а не при его создании.

Нет, преобразование выполняется лениво при обращении к элементам Да: transform_view сразу обходит диапазон и хранит новый vector transform_view удаляет исходный v Материализация происходит только для арифметических типов, а для классов view остаётся ленивым Результат вычисляется при компиляции

Вопрос 8 из 25

Почему view часто дёшево передавать по значению?

auto selected = values
    | std::views::drop(10)
    | std::views::take(20);
// selected хранит представление, а не двадцать скопированных элементов

Компилятор обязан удалить передачу по значению для любого типа view Передача стирает тип view до нетипизированного указателя Создание view продлевает время жизни элементов исходного диапазона до конца программы View принципиально не содержит ни указателей, ни callable, ни другого состояния Обычно копируются лишь небольшие ссылки, границы и callable, а не все элементы

Вопрос 9 из 25

Что делает `std::views::all(r)` для lvalue-контейнера?

std::vector<int> values{1,2,3};
auto view = std::views::all(values);

values[0] = 9;
std::cout << view.front();

Для lvalue std::views::all создаёт owning_view с собственной копией контейнера Преобразует r в initializer_list Возвращает только первый элемент Удаляет r Обычно создаёт ref_view, ссылающийся на r

Вопрос 10 из 25

Почему тип конкретной цепочки views редко стоит писать вручную?

View всегда имеет тип std::vector Имена типов запрещены стандартом auto делает копию элементов Тип цепочки сложен; `auto` сохраняет его точно Тип неизвестен до runtime

Вопрос 11 из 25

Какой результат даст цепочка?

#include <iostream>
#include <ranges>
#include <vector>
int main(){
    std::vector<int> v{1,2,3,4};
    auto r = v | std::views::filter([](int x){return x%2==0;})
               | std::views::transform([](int x){return x*2;});
    for(int x:r) std::cout<<x<<" ";
}

`4 8` `2 6` `4 8 12 16` `2 4 6 8` Код не компилируется

Вопрос 12 из 25

Почему перестановка transform и filter может изменить и результат, и стоимость?

filter сортирует диапазон Адаптеры всегда коммутативны Меняются данные для predicate и число вызовов transform Компилятор волен переставить filter и transform, если оба адаптера записаны в одном pipeline transform выполняется только один раз при создании view

Вопрос 13 из 25

Можно ли полагаться, что transform-функция с побочным эффектом вызовется ровно один раз на элемент?

Нет, потому что функция transform вообще не вызывается при обходе view Да: стандарт требует кэшировать результат transform для каждого элемента после первого обращения Да, если callable имеет изменяемое состояние и не является const Нет: ленивый view может вычислять значение повторно при разных проходах или обращениях Гарантия однократности существует лишь для первого элемента диапазона

Вопрос 14 из 25

Что может быть дорогим у filter_view?

Перед первым обходом filter_view обязан отсортировать базовый диапазон по результату предиката Для каждого отвергнутого элемента view выполняет динамическое выделение узла Предикат вычисляется ровно один раз при построении view и больше не участвует в обходе Создание filter_view немедленно копирует весь исходный диапазон в отдельный контейнер Каждый переход к следующему элементу может снова искать ближайший элемент, удовлетворяющий предикату

Вопрос 15 из 25

Как ограничить бесконечный iota_view первыми десятью значениями?

auto first_ten = std::views::iota(0)
               | std::views::take(10);

for (int value : first_ten)
    std::cout << value << ' ';

`std::ranges::sort(iota)` `std::views::filter(10)` `std::views::iota(0).resize(10)` `std::views::drop(-10)` `std::views::iota(0) | std::views::take(10)`

Вопрос 16 из 25

Какой дефект времени жизни скрыт в возвращаемом filter_view?

auto positives(){
    std::vector<int> v{-1,2,3};
    return v | std::views::filter([](int x){return x>0;});
}

views нельзя возвращать из функций Лямбда всегда dangling vector живёт до конца программы filter_view ссылается на уничтоженный локальный vector filter_view копирует vector дважды

Вопрос 17 из 25

Что такое borrowed_range?

Range, итераторы которого могут оставаться действительными после завершения жизни самого объекта range Любой lvalue-range независимо от времени жизни его итераторов после уничтожения объекта диапазона Контейнер с тривиальным деструктором Диапазон, чья база обязана храниться через shared_ptr Диапазон, который обязательно размещает элементы в памяти другого объекта

Вопрос 18 из 25

Зачем ranges-алгоритмы иногда возвращают `std::ranges::dangling`?

auto find_zero() {
    return std::ranges::find(std::vector{3, 0, 4}, 0);
}

static_assert(std::is_same_v<decltype(find_zero()), std::ranges::dangling>);

Чтобы удалить элементы Чтобы вернуть безопасный итератор, который продлевает жизнь временного контейнера до конца функции Чтобы не вернуть висячий итератор временного диапазона Чтобы заменить iterator на nullptr Чтобы сообщить об ошибке runtime

Вопрос 19 из 25

Почему view над `std::initializer_list` опасно сохранять?

auto make_view() {
    std::initializer_list<int> values{1,2,3};
    return values | std::views::drop(1);
}

auto view = make_view();
std::cout << *view.begin();

Элементы нельзя читать даже в выражении Опасность только для double initializer_list всегда выделяет глобальную память Элементы initializer_list живут слишком недолго View копирует только последний элемент

Вопрос 20 из 25

Как безопасно хранить отфильтрованные данные как поле долгоживущего объекта?

Хранить только iterator begin Сохранить view на локальный параметр Вызвать std::move на ссылке и забыть владельца Хранить контейнер с view либо материализовать результат Использовать const_cast

Вопрос 21 из 25

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

Проверить forward и отклонить input-only Запустить только с vector Проверить имя типа строкой Сравнить sizeof итератора Измерить время одного прохода

Вопрос 22 из 25

Как обнаружить повторное выполнение transform?

Сравнить адрес объекта view до и после обхода Добавить в callable счётчик и выполнить повторные или частичные обходы view Отключить оптимизацию и предположить, что каждый элемент вычислится один раз Вызвать capacity у базового контейнера и связать её изменение с transform Сделать callable constexpr, не регистрируя число вызовов

Вопрос 23 из 25

Какой тест ловит view на уничтоженную базу?

Вызвать после смерти базы под AddressSanitizer Проверить только ненулевой размер view после возврата из функции-фабрики Сделать базу static в тесте Не обращаться к результату Проверить только тип компиляции

Вопрос 24 из 25

Почему результат pipeline стоит сравнить с простым эталонным циклом?

Цикл всегда быстрее и потому заменяет тест Эталон нужен только для сортировки Ranges не детерминированы Pipeline нельзя отлаживать Эталонный цикл независимо проверяет порядок и границы

Вопрос 25 из 25

Что профилировать в длинной цепочке views?

Только количество строк кода Только время создания объекта view Вызовы, проходы, кэш и materialization Только компиляцию заголовка Только размер исходного контейнера

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

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

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

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