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

Перегрузка операторов

Вопросы проверяют не способность написать `operator+`, а умение сохранить смысл привычного оператора. Неправильная перегрузка может компилироваться и всё же разрушать ожидания о симметрии, транзитивности, побочных эффектах и стоимости.

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

⏱ --:--

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

Вопрос 1 из 20

Почему `operator+` часто реализуют как свободную функцию через `operator+=`?

class Number {
public:
    Number& operator+=(const Number& rhs) {
        value_ += rhs.value_;
        return *this;
    }
    friend Number operator+(Number lhs, const Number& rhs) {
        lhs += rhs;
        return lhs;
    }
private:
    int value_ = 0;
};

Свободная функция имеет особую гарантию встраивания и потому быстрее метода Так переиспользуют `operator+=` и допускают неявные преобразования также для левого операнда Схема допустима лишь у оболочек над указателями; для значений operator+ обязан быть членом Составной оператор обязан быть виртуальным, а бинарный — свободным Член класса не может возвращать новый объект того же типа

Вопрос 2 из 20

Какой возвращаемый тип типичен для `T& operator+=(const T&)`?

class Matrix {
public:
    Matrix& operator+=(const Matrix& rhs) {
        add_in_place(rhs);
        return *this;
    }
};

(a += b) += c;

Константный bool, показывающий, изменилось ли значение `T&`, чтобы поддерживать цепочки составных присваиваний Владеющий указатель на новую копию результата Нетипизированный указатель на изменённый объект `T&&`, поскольку левый операнд после изменения становится временным объектом

Вопрос 3 из 20

Какое значение получится у (a + b).v при реализации operator+ через operator+=?

#include <iostream>
struct N {
    int v;
    N& operator+=(const N& x){ v += x.v; return *this; }
};
N operator+(N a, const N& b){ return a += b; }
int main(){ N a{2}, b{5}; std::cout << (a+b).v; }

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

Вопрос 4 из 20

Какая перегрузка нужна, чтобы работало выражение `2 + Number{3}`, если Number имеет неявный конструктор из int?

class Number {
public:
    Number(int value) : value_(value) {}
    friend Number operator+(Number lhs, const Number& rhs) {
        lhs.value_ += rhs.value_;
        return lhs;
    }
private:
    int value_;
};

auto x = 2 + Number{3};

Оператор индексирования используется как посредник для симметричной арифметики Нужна подходящая свободная перегрузка, например `operator+(Number, const Number&)` Конструктор должен быть explicit, после чего оба операнда всё равно преобразуются автоматически Нужен отдельный деструктор Number, создающий временный левый операнд Достаточно только члена `Number::operator+(Number)`: левый int сначала выберет метод правого операнда

Вопрос 5 из 20

Почему арифметический `operator+` обычно не должен менять левый операнд?

Number a{2};
Number b{3};
Number c = a + b;

// После выражения a и b обычно должны сохранить прежние значения.
std::cout << a << ' ' << b << ' ' << c;

Оператор + всегда consteval Компилятор запрещает менять поля в операторе Изменение разрешено лишь в operator- Это возможно только для float Сумма ожидается без изменения исходных объектов

Вопрос 6 из 20

Какое свойство обязательно для корректного operator==?

Результат равенства должен совпадать с результатом operator< для любой пары неравных объектов Равенство должно быть нетранзитивным Если a == b, то b == a Результат обязан зависеть от адреса объекта operator== должен возвращать int больше нуля

Вопрос 7 из 20

Почему сравнение double через точное `a == b` может быть неверно для результатов вычислений?

double a = 0.1 + 0.2;
double b = 0.3;

std::cout << std::boolalpha << (a == b);
// Для предметного типа может понадобиться явная политика допуска.

Double сохраняет только целую часть и потому теряет любое дробное сравнение Встроенный operator== для double возвращает false даже для одинаковых битовых представлений Проблема возникает лишь у отрицательных чисел из-за отдельного бита знака Double нельзя сравнивать оператором равенства: такой код не компилируется Округления последовательности вычислений могут дать близкие, но не идентичные значения

Вопрос 8 из 20

Что может сгенерировать компилятор из `auto operator<=>(const X&) const = default;`?

struct Version {
    int major;
    int minor;
    auto operator<=>(const Version&) const = default;
};

static_assert(Version{1,2} < Version{2,0});

Хеш-функцию Только operator!= Виртуальную таблицу Сравнение полей по порядку Копирующий конструктор

Вопрос 9 из 20

Что требуется от компаратора для `std::sort`?

std::vector<Item> items = load_items();
std::sort(items.begin(), items.end(),
    [](const Item& a, const Item& b) {
        return a.priority < b.priority;
    });

Только полная линейная упорядоченность без эквивалентных элементов Он должен сравнивать только адреса Строгий слабый порядок Он обязан менять элементы Он должен иногда возвращать true для comp(x,x)

Вопрос 10 из 20

Почему сравнение объектов только по `name`, если equality учитывает ещё `id`, может быть проблемой в `std::set`?

struct User {
    int id;
    std::string name;

    friend bool operator==(const User&, const User&) = default;
    friend bool operator<(const User& a, const User& b) {
        return a.name < b.name;
    }
};

std::set<User> users;

set хранит только строки Проблемы нет, set разрешает любые дубли set использует operator== вместо компаратора `set` сочтёт одинаковые name эквивалентными ключами id всегда будет обнулён

Вопрос 11 из 20

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

struct Point { int x, y; };

std::ostream& operator<<(std::ostream& out, const Point& p) {
    return out << '(' << p.x << ", " << p.y << ')';
}

`std::istream operator<<(T&)` `T& operator<<(const std::ostream&)` `std::ostream& operator<<(std::ostream&, const T&)` `void operator<<(T, std::ostream)` `bool operator<<(int)`

Вопрос 12 из 20

Зачем operator<< возвращает std::ostream&?

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

Вопрос 13 из 20

Должен ли operator<< быть friend класса?

Только для ostream из файла Нет, friend запрещён для операторов Только если класс final Да, любой свободный оператор обязан быть friend Нет, только если нужен доступ к private

Вопрос 14 из 20

Какую ошибку содержит реализация?

std::ostream& operator<<(std::ostream& out, const X& x) {
    std::cout << x.value();
    return out;
}

Оператор должен возвращать bool Она пишет в std::cout вместо переданного потока out Параметр x обязан быть неконстантным Нельзя выводить int friend запрещает использование cout

Вопрос 15 из 20

Как безопасно временно изменить формат потока внутри operator<< и восстановить его?

Вызвать clear(), который сбрасывает форматирование вместе с флагами ошибок Сохранить нужные flags и precision либо использовать RAII-охранник состояния потока Закрыть поток и открыть его заново с начальными настройками Временно изменить глобальный cout, даже если operator получает другой ostream Скопировать ostream по значению, изменить копию и вернуть её вызывающему коду

Вопрос 16 из 20

Можно ли изменить приоритет операторов перегрузкой?

Да для оператора-члена, поскольку левый операнд определяет разбор выражения Нет: приоритет и ассоциативность задаются грамматикой языка Только `operator<<` может менять приоритет в зависимости от типа потока Да: constexpr-перегрузка может изменить грамматическую таблицу приоритетов Изменение разрешено только оператору в шаблонном классе

Вопрос 17 из 20

Можно ли создать новый оператор, например `**` для степени?

struct Number {
    int value;
    friend Number operator*(Number a, Number b) {
        return {a.value * b.value};
    }
};

// Синтаксис a ** b добавить нельзя: такого оператора в языке нет.

Нельзя: перегружать разрешено только уже существующие операторы языка Можно определить `**` макросом и получить настоящий новый оператор языка Можно только для встроенных числовых типов без пользовательских классов Можно, но только внутри пространства имён `std` для стандартных типов Можно ввести любой новый набор символов, если оба операнда пользовательских типов

Вопрос 18 из 20

Почему перегрузка `operator&&` не сохраняет поведение встроенного &&?

struct Flag {
    bool value;
};

bool operator&&(Flag left, Flag right) {
    return left.value && right.value;
}

bool result = make_left() && make_right();

Перегрузка разрешена лишь для пользовательского класса, не содержащего bool-полей Перед вызовом автоматически вычисляется operator! обоих операндов и сравниваются результаты Оба операнда обычного вызова функции вычисляются, поэтому короткое замыкание теряется Пользовательская перегрузка обязана возвращать int, а встроенная — bool Перегружать `operator&&` запрещено, поэтому проблема возникает на этапе разбора

Вопрос 19 из 20

Какой контракт естественен для `operator[]` контейнера?

class Buffer {
public:
    std::byte& operator[](std::size_t i) { return data_[i]; }
    const std::byte& operator[](std::size_t i) const { return data_[i]; }
private:
    std::vector<std::byte> data_;
};

Запуск сетевого запроса и изменение глобального состояния Доступ к элементу с контрактом, согласованным с контейнером Обязательная сортировка при каждом чтении Возвращать элемент по внутреннему порядку хранения, даже если он не соответствует переданному индексу Удаление всего контейнера

Вопрос 20 из 20

Почему `operator bool` часто объявляют explicit?

class FileHandle {
public:
    explicit operator bool() const noexcept { return handle_ != invalid; }
private:
    NativeHandle handle_ = invalid;
};

if (file) read(file);
// int n = file; // неявное числовое преобразование не нужно

Для условий без неожиданных числовых преобразований Чтобы запретить `if (obj)` Чтобы оператор вызывался только компоновщиком Чтобы объект всегда считался true Чтобы bool стал виртуальным

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

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

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

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