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

Функции и перегрузка

Здесь мало узнать знакомую сигнатуру: нужно понять, какие объявления обозначают одну функцию, как формируется множество кандидатов и почему близкая на вид перегрузка иногда делает вызов неоднозначным.

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

⏱ --:--

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

Вопрос 1 из 20

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

Да, если возвращаемые типы имеют различный ранг стандартного преобразования Нет: возвращаемый тип не входит в набор признаков, по которым выбирают перегрузку Нет только для свободных функций; методы класса могут различаться одним возвращаемым типом Да: контекст присваивания результата участвует в разрешении перегрузки Да, если одно определение inline, а второе имеет внешнее связывание

Вопрос 2 из 20

Какие два объявления обозначают одну и ту же функцию, а не две перегрузки?

void f(int value);
void f(const int value); // повторное объявление той же функции

void g(int& value);
void g(const int& value); // другая перегрузка

`void f(int&)` и `void f(const int&)` `void f(int*)` и `void f(const int*)` `void f(int)` и `void f(long)` `void f(int&)` и `void f(int&&)` `void f(int)` и `void f(const int)`

Вопрос 3 из 20

Что нужно добавить, чтобы метод можно было вызвать через const-объект?

struct Report {
    int pages() /* что добавить? */ { return 12; }
};

const перед именем класса const перед типом возвращаемого значения static перед именем метода Квалификатор const после списка параметров mutable у всех полей

Вопрос 4 из 20

Какой тип имеет переменная `pf`?

using Handler = int (*)(double);
Handler pf = nullptr;

Указатель на функцию, которая принимает double и возвращает int Ссылка на функцию, не принимающую аргументов и возвращающую Handler Функция с параметром double, возвращающая указатель на int Указатель на int, дополнительно квалифицированный списком параметров double Массив указателей на функции, индексируемый значением double

Вопрос 5 из 20

Какое объявление корректно описывает функцию, которая принимает массив как параметр?

void inspect(int* data);
void inspect_with_size(int data[10]);

template<std::size_t N>
void inspect_exact(int (&data)[N]);

int values[10]{};

`void f(std::array<int, 10> a)` является тем же объявлением, что и `void f(int a[10])` `void f(int (&a)[10])` эквивалентно указателю и не проверяет размер на этапе компиляции `void f(int a[10])` сохраняет размер 10 как часть типа параметра и отклонит меньший массив `void f(int* a)` соответствует скорректированному типу параметра, записанного как массив `void f(int a[])` копирует все элементы массива в локальный параметр функции

Вопрос 6 из 20

Какой кандидат выигрывает при вызове f(10)?

#include <iostream>
void f(int) { std::cout << "int"; }
void f(double) { std::cout << "double"; }
int main() { f(10); }

f(int) Обе Ни одна Вызов неоднозначен f(double)

Вопрос 7 из 20

Каков результат вызова f(1u)?

void f(int);
void f(unsigned);
void f(long);
f(1u);

f(unsigned) Вызов неоднозначен f(long) При равных преобразованиях выбирается кандидат, объявленный раньше f(int)

Вопрос 8 из 20

Почему вызов g(0) неоднозначен?

void g(long);
void g(double);
g(0);

Неоднозначность возникает потому, что литерал 0 нельзя использовать в числовой перегрузке double всегда имеет приоритет, но функция не определена Компилятор сравнивает размер long и double и при равенстве не может выбрать функцию int→long и int→double имеют одинаковый ранг 0 считается nullptr и подходит только к long

Вопрос 9 из 20

Какая перегрузка выберется для строкового литерала?

#include <string>
void f(const char*);
void f(std::string);
f("abc");

`f(std::string)` `f(std::string)` только в C++20 Вызов неоднозначен `f(const char*)` Ни одна

Вопрос 10 из 20

Какой кандидат выберет разрешение перегрузки для вызова f(1)?

#include <iostream>
template<class T> void f(T) { std::cout << "template"; }
void f(double) { std::cout << "double"; }
int main() { f(1); }

Нешаблонная перегрузка с параметром double, потому что обычная функция всегда имеет абсолютный приоритет Выбор откладывается до оптимизации и может различаться между отладочной и выпускной сборкой Шаблонная перегрузка с T = int, поскольку она даёт точное совпадение без преобразования Вызов неоднозначен: точное совпадение шаблона и стандартное преобразование обычной функции имеют одинаковый ранг Код не компилируется, потому что шаблон и нешаблонную функцию нельзя помещать в один набор перегрузок

Вопрос 11 из 20

Какое объявление допустимо?

void write(std::string_view text, int retries = 3);
// void write(std::string_view text = "", int retries); // ошибка

write("hello");

`void f(int = 0, int)` `void f(int x, int y = 0)` `void f(int x = 0, int y)` `void f(default int x)` `void f(int x,, int y = 0)`

Вопрос 12 из 20

Какое число напечатает виртуальный вызов p->show() без явного аргумента?

#include <iostream>
struct Base { virtual void show(int x = 1) { std::cout << x; } };
struct Derived : Base { void show(int x = 2) override { std::cout << x; } };
int main() { Derived d; Base* p = &d; p->show(); }

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

Вопрос 13 из 20

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

В отдельной переменной окружения Одновременно в каждом объявлении и определении Только в определении .cpp, скрытом от вызывающего кода Только в точке вызова В объявлении, видимом вызывающему коду, обычно в заголовке

Вопрос 14 из 20

Что произойдёт с вызовом `log()` после двух объявлений ниже в одной области видимости?

void log(int level);
void log(int level = 1);
log();

Вызов неоднозначен между вариантом с явным параметром и вариантом со значением по умолчанию Добавить значение по умолчанию можно только в первом объявлении функции Вызов корректен: второе объявление добавляет ранее не заданное значение по умолчанию Второе объявление создаёт отдельную перегрузку без параметров Повторное объявление допустимо, но значение по умолчанию учитывается только в последующих единицах трансляции

Вопрос 15 из 20

Почему значения по умолчанию не стоит использовать как скрытый механизм изменения поведения библиотеки?

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

Вопрос 16 из 20

Какая версия process будет вызвана для временного объекта?

struct Item {};
void process(Item&);
void process(const Item&);
void process(Item&&);
process(Item{});

`process(Item&)` `process(Item&&)` Вызов неоднозначен `process(const Item&)` всегда имеет приоритет Временные объекты нельзя передавать в функции

Вопрос 17 из 20

Почему `swap(a, b)` внутри шаблона часто пишут после `using std::swap;` без квалификатора?

template<class T>
void exchange_values(T& a, T& b) {
    using std::swap;
    swap(a, b); // учитывает перегрузку в пространстве имён T
}

`std::swap` виден обычно, а ADL находит swap типа Чтобы запретить ADL Потому что std::swap нельзя вызывать с двумя аргументами Чтобы всегда вызвать только член a.swap Это требуется лишь для C++98

Вопрос 18 из 20

Что произойдёт в Derived::test()?

struct Base { void f(int); };
struct Derived : Base {
    void f(double);
    void test() { f(1); }
};

Будет вызван Base::f(int) как точное совпадение Совпадение имени само по себе добавляет базовые функции в набор кандидатов Derived Всегда будет вызван Derived::f(double), но только после предупреждения Код имеет неопределённое поведение Вызов f(1) не найдёт Base::f(int), потому что имя f скрыто методом Derived::f(double)

Вопрос 19 из 20

Какая перегрузка метода value() будет вызвана для `std::move(x)`?

#include <utility>
struct X {
    int value() & { return 1; }
    int value() && { return 2; }
};
X x;
int n = std::move(x).value();

Обе Вызов неоднозначен `value() &&` `value() &` Ни одна, потому что std::move уничтожает x

Вопрос 20 из 20

Какое исправление наиболее точно устраняет неоднозначность вызова `f(nullptr)`?

void f(int*);
void f(double*);
f(nullptr);

Сделать оба указателя volatile Добавить inline к одной перегрузке Заменить nullptr на 0 Перегрузка `f(std::nullptr_t)` или явное приведение Поменять порядок объявлений функций

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

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

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

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