Основные правила и идиомы перегрузки операторов в C++

Основные правила перегрузки операторов

Перегрузка операторов в C++ — мощный, но опасный инструмент. Главное правило: семантика оператора должна быть интуитивно понятна. Не перегружайте `+` для вычитания — это приведёт к путанице.

Какие операторы можно перегружать?

• Почти все: арифметические (+, -, *, /, %), сравнения (==, !=, <, >), присваивания (=, +=), индексации ([]), вызова функции (()), потоки ввода/вывода (<<, >>)
• Нельзя перегружать: ::, . (точка), .*, ?:, sizeof, typeid, а также новые операторы (например, **)
• Операторы &&, || и , теряют свойство short-circuit evaluation при перегрузке

Два способа перегрузки

Есть два подхода: как метод класса (унарные и некоторые бинарные) и как свободная функция (обычно friend для доступа к приватным полям).

Исправленный класс Vector2D

class Vector2D {
public:
    Vector2D(double x = 0, double y = 0) : x_(x), y_(y) {}
    
    // 1. Оператор += (возвращает ссылку!)
    Vector2D& operator+=(const Vector2D& other) {
        x_ += other.x_;
        y_ += other.y_;
        return *this;
    }
    
    // 2. Оператор + как свободная функция (дружественная)
    friend Vector2D operator+(const Vector2D& lhs, const Vector2D& rhs) {
        Vector2D result = lhs;
        result += rhs;
        return result;
    }
    
    // 3. Оператор вывода в поток
    friend std::ostream& operator<<(std::ostream& os, const Vector2D& v) {
        os << "(" << v.x_ << ", " << v.y_ << ")";
        return os;
    }
    
    // 4. Оператор == для сравнения
    friend bool operator==(const Vector2D& lhs, const Vector2D& rhs) {
        return (lhs.x_ == rhs.x_) && (lhs.y_ == rhs.y_);
    }
    
    // 5. Оператор != через == (идиома!)
    friend bool operator!=(const Vector2D& lhs, const Vector2D& rhs) {
        return !(lhs == rhs);
    }

private:
    double x_, y_;
};

Почему так, а не иначе?

• operator+= как метод: он модифицирует объект, поэтому возвращает ссылку на себя (*this). Это позволяет писать цепочки: a += b += c;
• operator+ как свободная функция: если бы это был метод, то 2.0 + v не сработало бы (левый операнд — double, у него нет метода operator+). Свободная функция принимает оба аргумента, поэтому работает и v + 2.0, и 2.0 + v (если есть конструктор от double).
• friend: нужен для доступа к приватным полям. Без этого пришлось бы использовать геттеры, что менее эффективно.
• operator<< и operator>>: всегда свободные функции, потому что левый операнд — поток (ostream/istream), а не ваш класс.

Идиомы и правила

• Правило трёх/пяти: если перегружаете оператор присваивания (=), не забудьте про конструктор копирования и деструктор (или используйте правило нуля с умными указателями).
• Бинарные операторы через составные: operator+ реализуйте через operator+=, operator- через operator-= и т.д. Это уменьшает дублирование кода.
• Операторы сравнения: реализуйте == и <, а остальные (<, >, <=, >=, !=) через них с помощью std::rel_ops или C++20 spaceship operator (<=>).
• Префиксный и постфиксный инкремент: префиксный (++x) возвращает ссылку, постфиксный (x++) — копию старого значения.
• Оператор []: обычно две версии — const и non-const, возвращающие ссылку.
• Оператор () (функтор): может принимать любое количество аргументов.

Полный пример использования

int main() {
    Vector2D v1(1.0, 2.0);
    Vector2D v2(3.0, 4.0);
    
    Vector2D v3 = v1 + v2;          // (4, 6)
    Vector2D v4 = v1 + 2.0;         // работает: 2.0 -> Vector2D(2, 0)
    Vector2D v5 = 2.0 + v1;         // работает благодаря свободной функции!
    
    std::cout << v3 << std::endl;  // вывод: (4, 6)
    
    v1 += v2;                       // v1 стал (4, 6)
    
    if (v1 == v3) {
        std::cout << "Равны!" << std::endl;
    }
    
    return 0;
}

Золотое правило: если сомневаетесь — не перегружайте. Перегрузка должна делать код читаемее, а не превращать его в магию.

#include <compare>

class Vector2D {
public:
    Vector2D(double x = 0, double y = 0) : x_(x), y_(y) {}
    
    // Автоматически генерирует ==, !=, <, >, <=, >=
    auto operator<=>(const Vector2D&) const = default;
    
    // Оператор + можно оставить как свободную функцию
    friend Vector2D operator+(const Vector2D& lhs, const Vector2D& rhs) {
        return Vector2D(lhs.x_ + rhs.x_, lhs.y_ + rhs.y_);
    }
    
    // Вывод в поток — как обычно
    friend std::ostream& operator<<(std::ostream& os, const Vector2D& v) {
        os << "(" << v.x_ << ", " << v.y_ << ")";
        return os;
    }

private:
    double x_, y_;
};