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

Concepts и ограничения шаблонов

Тест проверяет, умеет ли разработчик превратить неявные ожидания шаблона в явный контракт. Задания сравнивают requires-выражения, именованные концепты и старые приёмы SFINAE, а также показывают, как слишком широкое или слишком узкое ограничение портит интерфейс.

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

⏱ --:--

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

Вопрос 1 из 25

Что проверяет это requires-выражение?

template<class T>
concept Sized = requires(T a) {
    a.size();
};

Что size() возвращает int Что T обязан наследоваться от std::vector Что size() вызывается во время компиляции Что для значения a типа T допустимо выражение a.size() Что объект a создаётся в runtime

Вопрос 2 из 25

Как потребовать, чтобы `a.size()` возвращал тип, преобразуемый в std::size_t?

template<class T>
concept HasSize = requires(const T& a) {
    { a.size() } -> std::convertible_to<std::size_t>;
};

static_assert(HasSize<std::vector<int>>);

`a.size() == std::size_t;` внутри тела requires-выражения `static_cast<void>(T);`, проверяющий существование самого типа T `return std::size_t(a.size());` непосредственно внутри определения концепта `typename a.size();`, объявляющее результат как зависимый тип `{ a.size() } -> std::convertible_to<std::size_t>;`

Вопрос 3 из 25

Что проверяет строка `typename T::value_type;` внутри requires?

template<class T>
concept HasValueType = requires {
    typename T::value_type;
};

static_assert(HasValueType<std::vector<int>>);

Что поле value_type имеет значение Что зависимый тип T::value_type существует Что value_type равен T Что value_type создаётся в куче Что T является typename

Вопрос 4 из 25

Чем `requires requires(T x) { x + x; }` отличается по роли двух requires?

template<class T>
requires requires(T x) { x + x; }
auto twice(T value) {
    return value + value;
}

Первое вводит trailing-ограничение, второе начинает requires-выражение Второе требует, чтобы выражение выбрасывало исключение при неверном типе Оба слова вводят одно requires-выражение; первое можно удалить без изменения грамматики Первое requires запускает проверку во время выполнения, второе действует при подстановке Первое объявляет анонимный concept, а второе создаёт обобщённую лямбду

Вопрос 5 из 25

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

template<class T>
concept SmallObject = requires {
    requires (sizeof(T) <= 64);
};

static_assert(SmallObject<int>);

Макросом, разворачивающимся в `true` или `false` до шаблона Выражением `throw`, если условие типа оказалось ложным Виртуальной функцией `bool`, вызываемой во время выполнения Обычным `if`, который выполняется при создании объекта концепта Вложенным требованием вида `requires condition;`

Вопрос 6 из 25

Что означает параметр `std::integral auto x`?

void add_to_total(std::integral auto value) {
    total += static_cast<std::int64_t>(value);
}

add_to_total(42);
// add_to_total(3.14);

Функция не является шаблоном Сокращённый шаблон для типов std::integral x всегда имеет тип int auto вычисляется только во время выполнения Принимаются double и string

Вопрос 7 из 25

Как объединить требования “Range” и “Sortable”?

template<class R>
concept SortableRange =
    std::ranges::random_access_range<R> &&
    std::sortable<std::ranges::iterator_t<R>>;

template<SortableRange R>
void normalize(R& values);

`inherit Range, Sortable` `Range<T> + Sortable<T>` `concept SortableRange(T)` `Range<T> && Sortable<T>` `Range<T> || Sortable<T>` если нужны оба

Вопрос 8 из 25

Почему концепт не должен называться просто `HasPlus`, если интерфейсу нужна упорядоченная денежная величина?

template<class T>
concept Money = requires(T a, T b) {
    { a + b } -> std::same_as<T>;
    { a < b } -> std::convertible_to<bool>;
    { a.currency() } -> std::same_as<Currency>;
};

Концептам запрещены глаголы Имя концепта не попадает в диагностику Такой концепт проверит только наличие синтаксиса, но компилятор всё равно выведет предметные свойства из имени Оператор + не выражает весь предметный контракт operator+ всегда отсутствует у денег

Вопрос 9 из 25

Что верно о стандартном `std::same_as<T,U>`?

template<class T, class U>
requires std::same_as<T, U>
void merge(T& dst, const U& src);

static_assert(std::same_as<int, int>);
static_assert(std::same_as<const int, const int>);

Он сравнивает значения T и U Он выполняет dynamic_cast Он симметрично требует совпадения типов Он проверяет одинаковый размер объектов Он допускает любые неявные преобразования

Вопрос 10 из 25

Что даёт запись `template<std::ranges::range R>`?

template<std::ranges::range R>
auto first_or_default(R&& range) {
    auto it = std::ranges::begin(range);
    if (it == std::ranges::end(range)) return Value{};
    return Value(*it);
}

Подставляемый R обязан удовлетворять `std::ranges::range` Ограничение исключает встроенные массивы, хотя для них определены begin и end Тип R должен владеть всеми элементами и не может быть невладеющим view R обязан быть random_access_range, поскольку ограничение записано в списке параметров шаблона R выводится из результата ranges::begin, а наличие корректного end не проверяется

Вопрос 11 из 25

Главное преимущество concepts перед глубокой SFINAE-ошибкой?

Они автоматически доказывают семантические свойства вроде строгого слабого порядка Ошибка ограничения диагностируется ближе к вызову Они уменьшают размер каждого объекта Concepts гарантируют отсутствие любых ошибок Они выполняют проверку только в runtime

Вопрос 12 из 25

Когда одна ограниченная перегрузка считается более специализированной?

Когда используется больше строк кода Когда возвращаемый тип меньше Когда она объявлена позже Она включает и усиливает ограничения другой Когда в её requires-clause текстуально больше требований, даже если логического следования нет

Вопрос 13 из 25

Почему два концепта с одинаковым текстом, но разными атомарными ограничениями могут дать неоднозначность?

При одинаковом написании преимущество получает concept, объявленный раньше в файле Неоднозначность возникает из-за виртуальной диспетчеризации constrained-функций При subsumption сравнивается структура атомарных ограничений, а не только визуально одинаковый текст Оператор && в ограничениях не участвует в упорядочивании перегрузок Два concept не могут содержать одинаковое выражение: второе объявление нарушает ODR

Вопрос 14 из 25

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

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

Вопрос 15 из 25

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

Выбирается кандидат с минимальным числом требований, даже если его constraints ложны Вызов станет runtime dispatch Будет возвращён nullptr Ограничения проигнорируются Подходящей функции не будет

Вопрос 16 из 25

Функция только читает диапазон один раз. Какое ограничение вероятнее всего достаточно?

template<std::ranges::input_range R>
std::size_t count_nonzero(R&& range) {
    std::size_t n = 0;
    for (auto&& x : range) if (x != 0) ++n;
    return n;
}

`std::ranges::input_range` `std::copyable` для самого диапазона обязательно `std::vector` как единственный тип `std::ranges::random_access_range` обязательно `std::ranges::contiguous_range` обязательно

Вопрос 17 из 25

Почему ограничивать функцию `std::derived_from<Base>` иногда хуже параметра `Base&`?

struct Base {
    virtual ~Base() = default;
    virtual void draw() const = 0;
};

void render(const Base& object) {
    object.draw();
}

Параметр Base& создаёт временную базовую часть и тем самым срезает объект Derived derived_from не существует Для готового полиморфного интерфейса проще `Base&` Concepts нельзя использовать с классами Шаблон всегда меньше бинарно

Вопрос 18 из 25

Когда static_assert внутри шаблона всё ещё уместен при наличии concepts?

Для проверки внутреннего инварианта выбранной реализации после того, как интерфейс уже отфильтрован constraints Только в шаблоне, который вызывается напрямую из main, иначе сообщение не выводится Он больше не нужен: concepts выражают и интерфейсные, и все внутренние утверждения Для проверки runtime-значения, которое неизвестно во время компиляции Для замены любого requires: static_assert всегда участвует в выборе перегрузки так же

Вопрос 19 из 25

Как спроектировать две версии алгоритма для random-access и обычного forward-range?

Дублировать имена без ограничений Использовать макрос для каждого контейнера Две перегрузки: random_access_range и forward_range Один if по typeid во время выполнения Проверять адреса элементов

Вопрос 20 из 25

Какой концепт лучше всего выражает контракт показанного алгоритма?

template<class T>
concept Temperature = requires(T t) {
    { t.in_kelvin() } -> std::convertible_to<double>;
    { T::from_kelvin(0.0) } -> std::same_as<T>;
};

template<Temperature T>
double heat_loss(T inside, T outside);

`Arithmetic`, требующий любых арифметических операций над T `PersistableTemperature`, добавляющий неиспользуемый контракт сериализации `Temperature`, требующий `in_kelvin()` и `from_kelvin()` `HasInKelvinAndFactory`, перечисляющий текущие имена методов без предметного смысла `ConvertibleToDouble`, проверяющий только неявное преобразование всего объекта

Вопрос 21 из 25

Как проверить concept на этапе компиляции?

static_assert(std::ranges::range<std::vector<int>>);
static_assert(!std::ranges::range<int>);
static_assert(std::sortable<std::vector<int>::iterator>);

`try { MyConcept }` `dynamic_cast<MyConcept*>` `static_assert(MyConcept<MyType>);` `sizeof("concept")` `assert(MyConcept<MyType>)` только в runtime

Вопрос 22 из 25

Какой негативный тест полезен для концепта WritableRange?

Диапазон с записываемыми элементами, но пустой во время выполнения Тип без `begin/end`, который проверяет лишь отсутствие самого диапазона Пользовательский диапазон с изменяемыми элементами и корректными итераторами Тип с `begin/end`, возвращающими итераторы на const-элементы, в которые нельзя записать `std::vector<int>`, который полностью удовлетворяет ожидаемым требованиям концепта

Вопрос 23 из 25

Почему concept `requires(T x) { x < x; }` не гарантирует строгий слабый порядок?

template<class T>
concept HasLess = requires(T a, T b) {
    { a < b } -> std::convertible_to<bool>;
};

struct Cyclic {
    int value;
    friend bool operator<(Cyclic a, Cyclic b) {
        return (a.value + 1) % 3 == b.value % 3;
    }
};

Requires-выражение не умеет проверять синтаксис оператора < Строгий слабый порядок следует из размера T, а не из поведения оператора Нарушение порядка обязано проявляться исключением при первом сравнении Компилятор перебирает все значения T и тем самым проверяет транзитивность только для конечных типов Оно подтверждает допустимость выражения и тип результата, но не транзитивность, асимметрию и другие законы порядка

Вопрос 24 из 25

Как обнаружить, что концепт случайно требует копирование?

Измерить sizeof концепта Запустить профилировщик Добавить volatile ко всем переменным Проверить на корректном move-only типе Проверить только int

Вопрос 25 из 25

Что тестировать помимо `static_assert(Concept<T>)`?

template<class T>
concept WritableRange = requires(T r) {
    *std::ranges::begin(r) = std::ranges::range_value_t<T>{};
};

static_assert(WritableRange<std::vector<int>>);
// Нужны также проверки реального поведения алгоритма.

Лишь время компиляции положительного примера, не вызывая функцию Ничего: истинность concept доказывает корректность тела любого constrained-алгоритма Только текст имени concept в диагностике, без типов на границе требования Одно переименование T, поскольку поведение concept от структуры типа не зависит Положительные и отрицательные граничные типы в реальных constrained-функциях и проверку выбранной перегрузки

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

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

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

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