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

Классы и инкапсуляция

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

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

⏱ --:--

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

Вопрос 1 из 20

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

#include <iostream>
struct Pair {
    int a;
    int b;
    Pair() : b(a + 1), a(1) {}
};
int main() { Pair p; std::cout << p.a << p.b; }

11 12 21 Поведение не определено 22

Вопрос 2 из 20

Что означает `inline static int count = 0;` внутри класса в C++17 и новее?

struct Session {
    inline static int count = 0;

    Session()  { ++count; }
    ~Session() { --count; }
};

Session a;
Session b;

Поле существует только внутри inline-функций Каждый объект получает отдельную копию count Так можно объявлять только constexpr-поля Одно поле класса, определённое и инициализированное внутри него Поле пересоздаётся при каждом вызове конструктора

Вопрос 3 из 20

Почему поле `std::string_view name_` требует особого внимания?

class User {
public:
    explicit User(std::string_view name) : name_(name) {}
    std::string_view name() const { return name_; }
private:
    std::string_view name_;
};

User make_user() { return User{std::string("Ann")}; }

Хранить string_view полем нельзя даже при ссылке на строковый литерал со статическим временем жизни Опасность возникает лишь у строковых литералов, а view на std::string всегда продлевает её жизнь String_view владеет отдельной копией и синхронизирует её при изменении исходной строки Поле не владеет символами, поэтому источник должен оставаться живым и неподвижным всё время использования view Конструктор string_view переносит буфер исходной string и оставляет её пустой

Вопрос 4 из 20

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

Поле bool Статическое поле класса Виртуальный указатель при наличии виртуальных функций Поле пустого вложенного объекта без специальных атрибутов Обычное поле int

Вопрос 5 из 20

Что лучше всего выражает необязательное поле “дата последнего входа”?

class Account {
public:
    void mark_login(std::chrono::system_clock::time_point when);
private:
    // Какой тип поля лучше отражает отсутствие входа?
    /* ... */ last_login_;
};

`std::optional<TimePoint> last_login_` `bool has_login_` без поля, в котором можно сохранить саму дату Пара `TimePoint last_login_` и счётчик обращений, из которого выводят наличие значения `std::unique_ptr<TimePoint> last_login_`, хотя отдельное динамическое выделение не требуется `TimePoint last_login_`, где одна договорённая дата означает отсутствие

Вопрос 6 из 20

Почему статический метод не может напрямую обратиться к нестатическому полю value?

У статического метода нет указателя this и выбранного экземпляра класса Статические методы выполняются на этапе компиляции и не могут читать память объектов Нестатическое поле доступно лишь методам, объявленным private Квалификатор const у статического метода создаст скрытый this и разрешит доступ Нестатические поля размещаются в стеке, а статический метод — в статической памяти

Вопрос 7 из 20

Какое значение накопит Counter после двух последовательных вызовов add?

#include <iostream>
struct Counter {
    int value = 0;
    void add(int n) { value += n; }
};
int main() { Counter c; c.add(1); c.add(2); std::cout << c.value; }

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

Вопрос 8 из 20

Зачем у геттера иногда делают две перегрузки `T& get()` и `const T& get() const`?

class Buffer {
public:
    std::vector<std::byte>& data() { return data_; }
    const std::vector<std::byte>& data() const { return data_; }
private:
    std::vector<std::byte> data_;
};

Чтобы обе перегрузки вызывались одновременно Чтобы сохранять const-корректность и не копировать объект Чтобы скрыть поле от компилятора Чтобы запретить вызов на временных объектах Чтобы const-объект можно было менять через первую перегрузку

Вопрос 9 из 20

Как запретить получение ссылки на внутренний буфер из временного объекта?

class Packet {
public:
    std::span<const std::byte> bytes() const & { return data_; }
    std::span<const std::byte> bytes() const && = delete;
private:
    std::vector<std::byte> data_;
};

Удалить перегрузку `bytes() const &`, сохранив вызов только для rvalue Оставить только `bytes() const` без ссылочной квалификации Возвращать `const std::span<const std::byte>&` на временный объект span Добавить к `bytes()` спецификацию `noexcept` Объявить `bytes() const && = delete` и оставить рабочую перегрузку `bytes() const &`

Вопрос 10 из 20

Какой метод логичнее объявить const?

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

Вопрос 11 из 20

Кто может напрямую обращаться к private-члену класса?

Только объект, созданный в main Любая функция того же файла Сам класс, друзья и вложенные классы Только конструктор Любой производный класс

Вопрос 12 из 20

Почему `protected`-поле часто хуже private-поля с защищённым интерфейсом?

class BaseCache {
protected:
    std::vector<Entry> entries_;
};

class TimedCache : public BaseCache {
public:
    void clear_expired(); // может менять entries_ напрямую
};

Protected запрещает дальнейшее наследование от класса, в котором объявлено поле Protected превращает поле в глобальное имя, доступное из любой функции программы Шаблонный производный класс не может обращаться к protected-члену даже через объект текущего типа Производные классы могут менять представление напрямую и обходить проверки инварианта базового класса Private-поле требует отдельный указатель в каждом объекте и потому увеличивает размер

Вопрос 13 из 20

Что даёт объявление `friend class Serializer;`?

class Document {
    friend class Serializer;
private:
    std::string title_;
    std::vector<Page> pages_;
};

class Serializer {
public:
    Json write(const Document& doc) const;
};

Serializer получает доступ к private и protected членам этого класса Все методы текущего класса становятся public Serializer получает доступ, а текущий класс в ответ получает доступ к private Serializer Serializer становится базовым классом Объекты объединяются в один экземпляр

Вопрос 14 из 20

Какой интерфейс лучше защищает баланс банковского счёта?

Закрытое поле `balance_` и методы `deposit/withdraw` с проверкой правил Публичный метод, возвращающий изменяемую ссылку на `balance_` Защищённый указатель `char* balance_`, доступный всем наследникам Открытое поле `double balance_`, которое вызывающий код меняет напрямую Глобальная переменная баланса, общая для всех объектов счёта

Вопрос 15 из 20

Что не так с методом `std::vector<int>& items()` у класса, который обещает хранить только положительные числа?

class PositiveSet {
    std::vector<int> data_;
public:
    std::vector<int>& items() { return data_; }
};

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

Вопрос 16 из 20

Какой конструктор лучше поддерживает инвариант “denominator никогда не равен нулю”?

Нормализовать ноль до единицы без сообщения вызывающему коду Проверить denominator и выбросить исключение до завершения конструктора Хранить denominator как public Сохранить ноль и проверять его только непосредственно перед делением Выполнять проверку только в деструкторе

Вопрос 17 из 20

Почему отдельные сеттеры `set_min` и `set_max` могут быть опасны для диапазона?

class Range {
public:
    void set_min(int value) { min_ = value; }
    void set_max(int value) { max_ = value; }
private:
    int min_ = 0;
    int max_ = 10;
};

Range r;
r.set_min(20);

Сеттеры всегда медленнее прямого доступа Они запрещают копирование Отдельный вызов может временно нарушить min <= max Два метода нельзя объявлять в одном классе Проблема возникает только при наследовании

Вопрос 18 из 20

Как лучше представить состояние заказа, если допустимы только “создан”, “оплачен”, “отправлен”, “отменён”?

Четыре независимых bool-поля с проверкой допустимых сочетаний только при выводе заказа Закрытый enum class и методы, разрешающие только допустимые переходы Целое поле с числовыми кодами, которые любой клиент может присвоить напрямую Открытая строка состояния и перечень допустимых значений в документации Полиморфный указатель на описание состояния без единого владельца и правил перехода

Вопрос 19 из 20

Какой дефект есть в методе?

class Stock {
    int amount = 0;
public:
    void take(int n) { amount -= n; }
};

Параметр n обязан быть ссылкой Метод не может обращаться к private-полю unsigned всегда выбрасывает исключение Вычитание запрещено в методах После уменьшения amount значение может стать отрицательным

Вопрос 20 из 20

Какое решение лучше всего предотвращает появление “пустого, но якобы действительного” идентификатора?

Хранить std::string и проверять лишь при печати Хранить пустую строку как специальное значение и надеяться на проверки вызывающего кода Отдельный тип Id с проверяющим конструктором или фабрикой Сделать поле public для ручного контроля Использовать char* и nullptr как пустую строку

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

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

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

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