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

Типы, ссылки и const

Тест проверяет не знание таблицы типов, а способность проследить, какой именно объект существует, кто имеет право его менять и когда ссылка или указатель перестаёт быть действительным. Большинство ошибок здесь выглядят безобидно и проявляются лишь после небольшой правки кода.

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

⏱ --:--

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

Вопрос 1 из 20

Какое значение будет выведено?

#include <iostream>
int main() {
    double x = 1 / 2;
    std::cout << x;
}

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

Вопрос 2 из 20

Какая строка не пройдёт компиляцию из-за сужающего преобразования при списочной инициализации?

double n{3}; long n{42}; int n{3.14}; int n = 3.14; int n(3.14);

Вопрос 3 из 20

На типичной реализации с 32-битным unsigned int что напечатает программа?

#include <iostream>
#include <limits>
int main() {
    unsigned int x = std::numeric_limits<unsigned int>::max();
    std::cout << x + 1u;
}

Код не компилируется -1 0 4294967296 Поведение не определено

Вопрос 4 из 20

Какой тип получит переменная value?

auto value = 5 + 2.0;

long double double Тип зависит от значения во время выполнения float int

Вопрос 5 из 20

Какой способ лучше всего выразит требование «ровно 32-битное знаковое целое», если платформа его поддерживает?

`std::int32_t`, если реализация предоставляет точный 32-битный знаковый тип `long`, который всегда имеет 32 бита даже на LP64-платформе `int`, поскольку стандарт гарантирует ему ровно 32 бита на любой поддерживаемой платформе `signed`, являющийся отдельным типом фиксированной ширины `std::size_t`, хотя он предназначен для размеров и является беззнаковым

Вопрос 6 из 20

Что будет выведено?

#include <iostream>
int main() {
    int x = 10;
    int& ref = x;
    ref = 20;
    std::cout << x;
}

Поведение не определено 20 10 Код не компилируется 30

Вопрос 7 из 20

Какое утверждение о переменной copy верно?

int value = 7;
int& alias = value;
auto copy = alias;

copy — ссылка на value copy имеет тип const int& Тип copy выводится как int&& copy нельзя изменить copy — отдельный int со значением 7

Вопрос 8 из 20

Какой дефект времени жизни есть в функции bad()?

const int& bad() {
    int x = 42;
    return x;
}

Возвращаемая ссылка указывает на локальный объект, чья жизнь закончилась при выходе из функции Функция возвращает ссылку на одно статическое нулевое значение при каждом вызове Локальная переменная перемещается вместе со стековым хранилищем в вызывающую функцию При return ссылка автоматически материализует копию локального int у вызывающего кода Квалификатор const у результата продлевает время жизни локального объекта после return

Вопрос 9 из 20

Как долго живёт временная строка в этом фрагменте?

#include <string>
int main() {
    const std::string& s = std::string("abc");
    // s остаётся действительной здесь
}

До первого чтения s Только до точки с запятой в первой строке Время жизни не продлевается вообще До конца области видимости ссылки s До выхода из конструктора std::string

Вопрос 10 из 20

Какая сигнатура позволит функции действительно поменять переданный счётчик, не принимая null?

void increment(int* const value) int& increment() void increment(int& value) void increment(int value) void increment(const int& value)

Вопрос 11 из 20

Какое число напечатает программа?

#include <iostream>
int main() {
    int a[] = {10, 20, 30, 40};
    int* p = a;
    std::cout << *(p + 2);
}

Поведение не определено 30 40 20 3

Вопрос 12 из 20

Какой кандидат выберет вызов f(nullptr)?

#include <iostream>
void f(int*) { std::cout << "ptr"; }
void f(long) { std::cout << "long"; }
int main() { f(nullptr); }

Выбор зависит от размера указателя Ни одна: nullptr нельзя передать в функцию f(int*) f(long) Вызов неоднозначен

Вопрос 13 из 20

После какой операции p может стать недействительным?

#include <vector>
std::vector<int> v{1, 2, 3};
int* p = v.data();
v.push_back(4);

Лишь после явного delete p, хотя память принадлежит vector Сразу после `data()`: получение указателя само по себе инвалидирует буфер vector После чтения `*p`, потому что указатель vector считается одноразовым После копирования значения p в другой сырой указатель без изменения vector После операции вроде push_back, если она вызвала перераспределение внутреннего буфера

Вопрос 14 из 20

Как читается объявление `const int* p`?

int value = 42;
const int* p = &value;

// *p = 7;  // нельзя менять int через p
value = 7;   // сам объект не обязан быть const
p = nullptr; // адрес в p менять можно

p нельзя переназначить, но *p можно менять Нельзя менять ни p, ни *p p можно переназначить, но менять int через p нельзя p всегда указывает на объект, объявленный const Можно менять и p, и *p

Вопрос 15 из 20

Что неверно в освобождении памяти?

int* p = new int[10];
delete p;

Для массива, созданного new[], требуется delete[] Нужно заменить new[] на malloc, оставив delete Оператор delete по адресу определит, что память была выделена как массив, и вызовет delete[] Ошибка только в том, что p не обнулён Код корректен для тривиального типа int

Вопрос 16 из 20

Какая перегрузка size() будет вызвана для объекта c?

struct Box {
    int size() { return 1; }
    int size() const { return 2; }
};
const Box c;
int n = c.size();

size() Вызов неоднозначен size() const Обе перегрузки по очереди Ни одна: методы нельзя перегружать по const

Вопрос 17 из 20

Зачем поле cache обычно объявляют mutable?

Чтобы поле стало потокобезопасным mutable заставляет поле очищаться перед вызовом деструктора объекта Чтобы const-метод обновлял кэш без смены логического состояния Чтобы запретить копирование объекта mutable снимает private-защиту поля для кода, работающего с const-объектом

Вопрос 18 из 20

Каково поведение записи через p?

const int x = 5;
int* p = const_cast<int*>(&x);
*p = 9;

Будет выброшено std::bad_cast x станет равен 9 Код не компилируется из-за const_cast Компилятор обязан игнорировать запись Неопределённое поведение

Вопрос 19 из 20

Какое утверждение точнее всего описывает различие const и constexpr для переменной?

const всегда вычисляется во время компиляции, constexpr — только во время выполнения Различия нет ни в одном контексте const применим только к числам `constexpr` требует constant expression и подразумевает const constexpr разрешает менять значение после инициализации

Вопрос 20 из 20

Какую перегрузку show() выберет std::as_const(x)?

#include <iostream>
#include <utility>
struct X {
    void show() { std::cout << "mutable"; }
    void show() const { std::cout << "const"; }
};
int main() { X x; std::as_const(x).show(); }

constmutable const Вызов неоднозначен mutable Код не компилируется

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

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

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

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