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

Шаблоны функций и классов

Тест проверяет, умеет ли разработчик видеть момент инстанцирования, отличать вывод параметров от обычных преобразований и читать ошибки шаблонов как цепочку требований. Здесь недостаточно помнить синтаксис `template<class T>` — нужно понимать, какой код реально появится для конкретного T.

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

⏱ --:--

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

Вопрос 1 из 25

Что представляет параметр N?

#include <cstddef>
template<class T, std::size_t N>
struct Buffer { T data[N]; };

Параметр-шаблон, принимающий другой шаблон класса Имя нестатического поля, создаваемого в каждом объекте шаблонного класса Макрос препроцессора, подставляемый до разбора шаблона Нетиповой параметр шаблона типа `std::size_t` Обычный параметр конструктора, значение которого определяется только во время выполнения

Вопрос 2 из 25

Почему `Buffer<int, 4>` и `Buffer<int, 8>` — разные типы?

template<class T, std::size_t N>
struct Buffer {
    std::array<T, N> data;
};

static_assert(!std::is_same_v<Buffer<int,4>, Buffer<int,8>>);

Различие появляется лишь при оптимизации Это один тип с разным capacity Размер массива игнорируется типовой системой Значение нетипового параметра входит в специализацию шаблона Они различаются только во время выполнения

Вопрос 3 из 25

Что позволяет параметр `template<class> class Container`?

template<class T, template<class> class Container>
struct Store { Container<T> values; };

Передать совместимый шаблон класса как параметр Передать только std::vector<int> Вывести тип во время выполнения Создать виртуальный шаблон Передать готовый объект Container

Вопрос 4 из 25

Какой смысл у значения по умолчанию `class Alloc = std::allocator<T>`?

template<class T, class Alloc = std::allocator<T>>
class SmallVector {
public:
    using allocator_type = Alloc;
private:
    [[no_unique_address]] Alloc alloc_;
};

Аллокатор вычисляется во время выполнения Это создаёт глобальный allocator При пропуске Alloc компилятор одновременно выводит T как int и выбирает std::allocator<int> Параметр Alloc нельзя переопределить Аллокатор можно не указывать или заменить

Вопрос 5 из 25

Какое ограничение есть у параметров шаблона функций по умолчанию?

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

Вопрос 6 из 25

Какой T будет выведен?

template<class T> void f(T);
const int x = 3;
f(x);

`int` `int&` `const int&` `const int` `int&&`

Вопрос 7 из 25

Какой T будет выведен для параметра `T&`?

template<class T> void f(T&);
const int x = 3;
f(x);

`volatile int` `int` `const int` `const int&` `const volatile int`

Вопрос 8 из 25

Почему вызов `max(1, 2.0)` не выводит T для шаблона `max(T,T)`?

template<class T> T max(T a, T b);
auto x = max(1, 2.0);

Первый параметр шаблона обязан быть ссылкой, иначе deduction не выполняется Шаблоны функций не могут принимать double в качестве аргумента Оба параметра требуют одного T, но deduction получает int и double и не ищет их общий тип Вызов требует виртуальной перегрузки, поскольку аргументы имеют разные динамические типы Имя max зарезервировано стандартной библиотекой и блокирует пользовательский шаблон

Вопрос 9 из 25

Что сохраняет размер строкового литерала в параметре?

template<std::size_t N>
constexpr std::size_t literal_size(const char (&text)[N]) {
    return N - 1;
}

static_assert(literal_size("hello") == 5);

`void f(const char* text)` с вычислением размера внутри функции `template<std::size_t N> void f(const char (&text)[N])` `template<class T> void f(T* text)` с выводом длины из T `void f(std::string text)` с сохранением размера исходного литерала в типе `void f(char text)` с передачей первого символа литерала

Вопрос 10 из 25

Для какого аргумента `T&&` является forwarding reference?

template<class T>
void relay(T&& value) {
    consume(std::forward<T>(value));
}

std::string name = "Ada";
relay(name);
relay(std::string("Lin"));

Когда T выводится из вызова, а параметр имеет точную форму `T&&` Только внутри шаблона класса, где тип T уже задан при создании объекта Только для параметров функции `main`, объявленных через шаблон Только для формы `const T&&`, сохраняющей обе категории значения Для любого параметра, синтаксически записанного как rvalue-ссылка

Вопрос 11 из 25

Можно ли частично специализировать шаблон функции?

Да: синтаксис частичной специализации функции совпадает с частичной специализацией класса Нет, потому что шаблон функции нельзя специализировать даже полностью Она разрешена исключительно внутри namespace std для стандартных алгоритмов Частичная специализация доступна только constexpr-функциям Нет: вместо частичной специализации функций используют перегрузки

Вопрос 12 из 25

Что обозначает `Box<T*>`?

template<class T> struct Box;
template<class T> struct Box<T*> { static constexpr bool pointer = true; };

Полную специализацию Box для одного конкретного указательного типа, выбранного при первом использовании Частичную специализацию класса Box для любого указательного типа T* Шаблон функции, принимающей T* и возвращающей базовый Box Runtime-фабрику, создающую новый Box при каждом полученном указателе Наследование каждой специализации Box от типа, на который указывает T

Вопрос 13 из 25

Какая версия выберется для `Trait<int*>` при наличии первичного шаблона и специализации `Trait<T*>`?

template<class T> struct Trait { static constexpr bool pointer = false; };
template<class T> struct Trait<T*> { static constexpr bool pointer = true; };

static_assert(Trait<int*>::pointer);
static_assert(!Trait<int>::pointer);

Всегда первичный шаблон Код требует dynamic_cast Специализация для T* Обе одновременно Выбор не определён

Вопрос 14 из 25

Где должна быть объявлена явная специализация шаблона?

После всех инстанцирований В namespace исходного шаблона до использования Внутри любой функции Только в анонимном namespace Обязательно внутри класса-клиента

Вопрос 15 из 25

Почему перегрузка функции часто предпочтительнее её полной специализации?

Полная специализация функции рассматривается только для T=int, а остальные типы требуют перегрузки Перегрузка выполняется во время выполнения Перегрузка не создаёт машинный код Полные специализации функций запрещены, поэтому перегрузка является единственным допустимым способом Перегрузка полноценно участвует в выборе кандидатов

Вопрос 16 из 25

Почему шаблон компилируется до вызова с NoPlus?

template<class T>
auto add(const T& a, const T& b) { return a + b; }

NoPlus не считается типом Зависимое выражение проверяется при инстанцировании Ошибка появится только во время выполнения Компилятор не проверяет шаблоны вообще При первой инстанциации компилятор добавит подходящий operator+ через неявное преобразование

Вопрос 17 из 25

Зачем в зависимом имени пишут `typename T::value_type`?

template<class T>
void clear(T& container) {
    typename T::value_type zero{};
    container.assign(container.size(), zero);
}

Чтобы открыть новое пространство имён, заданное членом T Typename требуется перед каждым именем типа, включая независящие встроенные типы Чтобы сделать зависимый тип виртуальным и участвовать в диспетчеризации Чтобы запретить дальнейшие специализации value_type Чтобы сообщить парсеру: зависимое имя `T::value_type` следует трактовать как тип

Вопрос 18 из 25

Когда нужен ключ `template` в выражении вроде `obj.template get<0>()`?

template<class T>
auto read_first(T& object) {
    return object.template get<0>();
}
// get — зависимое шаблонное имя; без template разбор неоднозначен.

Вместо typename для обозначения зависимого вложенного типа Лишь внутри шаблона, объявленного непосредственно в функции main Чтобы разобрать зависимое имя члена как шаблон, например `obj.template get<0>()` Перед каждым вызовом шаблонной функции независимо от контекста зависимости Когда зависимый член имеет несколько перегрузок и одна из них объявлена шаблоном

Вопрос 19 из 25

Что означает SFINAE?

Любая ошибка внутри тела функции игнорируется Шаблон всегда выбирается первым Если подстановка не удалась, компилятор исправляет аргументы шаблона до ближайшего совместимого типа Ошибка подстановки удаляет кандидата, а не весь код Исключение ловится во время выполнения

Вопрос 20 из 25

Почему ошибка внутри вызываемой из шаблона обычной функции не обязана быть SFINAE?

Если ошибка возникла вне непосредственного контекста подстановки, она становится обычной жёсткой ошибкой Шаблоны не могут вызывать нешаблонные функции до завершения инстанцирования Обычная функция, вызванная из шаблона, не проходит стадию компиляции Любая ошибка, достигнутая через шаблонный вызов, обязана удалить кандидата по SFINAE SFINAE действует только для выражений с арифметическими типами

Вопрос 21 из 25

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

template<class T>
T duplicate(const T& value) {
    static_assert(std::is_copy_constructible_v<T>,
                  "duplicate requires a copy-constructible type");
    return T(value);
}

Выбросить строковый литерал в runtime при первой попытке копирования Добавить `static_assert` с trait, проверяющим copy-constructible, и понятным сообщением Удалить все конструкторы T из шаблона, чтобы компилятор выбрал копирующий автоматически Поместить требование только в документацию рядом с шаблоном и оставить обычную ошибку выражения Добавить перегрузку с `enable_if_t<is_copy_constructible_v<T>>`, но без отдельного сообщения

Вопрос 22 из 25

Что помогает сократить огромную трассу ошибки шаблона?

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

Вопрос 23 из 25

Зачем явно инстанцировать шаблон в .cpp и объявлять extern template в заголовке?

Чтобы запретить линковку Чтобы шаблон начал работать с любым неизвестным типом без определения Чтобы выполнять шаблон во время запуска Централизовать генерацию специализаций и ускорить сборку Чтобы сделать функцию виртуальной

Вопрос 24 из 25

Какой тест обнаружит скрытое требование default-конструктора у контейнерного шаблона?

Проверить размер бинарника Инстанцировать типом без default-конструктора Использовать только int Запустить с пустой строкой Открыть все поля тестового типа, чтобы контейнер смог создать его без конструктора по умолчанию

Вопрос 25 из 25

Почему тестирование только одной специализации шаблона недостаточно?

Тип T влияет лишь на размер текстовой диагностики и не меняет допустимые выражения Разные T могут включать иные ветви, категории операций и скрытые требования Все специализации шаблона после оптимизации обязаны иметь одинаковый машинный код Тела шаблонов проверяются исключительно линковщиком после генерации всех специализаций Проверка одной специализации int по стандарту считается доказательством корректности для всех T

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

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

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

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