Перегрузка операторов в C++: практическое руководство с примерами кода

Что такое перегрузка операторов?

С помощью перегрузки операторов в C++ можно придать одному оператору несколько значений в одной области видимости. Цель — задать пользовательское поведение оператора для пользовательского типа.

Перегрузка позволяет переопределить большинство операторов C++ и выполнять разные операции с одним символом.

В этом уроке вы узнаете:

• Что такое перегрузка операторов
• Синтаксис
• Разные подходы к перегрузке
• Какие операторы нельзя перегрузить
• Важные замечания
• Правила перегрузки
• Как перегрузить оператор на практике

Синтаксис

Для перегрузки оператора определите специальную функцию-член внутри класса:

class class_name {
    ...
public:
    return_type operator символ (аргументы) {
        ...
    }
    ...
};

Компоненты:

• return_type — тип, возвращаемый функцией-оператором.
• operator — ключевое слово, начинающее объявление.
• символ — перегружаемый оператор, например +, -, <, ++.
• аргументы — параметры, как у обычной функции.

Пример 1: Префиксный декремент

#include <iostream>
using namespace std;
class TestClass {
private:
    int count;
public:
    TestClass() : count(5) {}
    void operator --() {
        count = count - 3;
    }
    void Display() {
        cout << "Count: " << count;
    }
};
int main() {
    TestClass tc;
    --tc;
    tc.Display();
    return 0;
}

Вывод:

Скриншот кода:

Разбор кода:

1. Подключаем <iostream> для ввода/вывода.
2. Используем пространство имён std.
3. Определяем класс TestClass.
4. Поле count — private.
5. Публичный конструктор инициализирует count = 5.
6. Перегружаем префиксный -- для вычитания 3 из count.
7. Метод Display() печатает текущее значение.
8. В main() создаём экземпляр, применяем перегруженный оператор, выводим результат.

Подходы к перегрузке операторов в C++

Перегрузка достигается через:

1. Функции-члены класса
2. Не-член-функции (friend или свободные функции)
3. Friend-функции (когда нужен доступ к private данным)

• Если левый операнд — объект класса, обычно используют функцию-член.
• Если левый операнд — другой тип, нужна не-член-функция.
• Friend-функции полезны, когда оператору нужен доступ к private/protected членам.

Можно ли перегрузить все операторы C++?

Нет. Следующие операторы нельзя перегрузить:

• :: — разрешение области видимости
• ?: — тернарный условный
• . — доступ к члену
• sizeof — запрос размера
• * (указатель на член класса)

Что нужно помнить

1. Перегрузка влияет только на пользовательские типы; встроенные типы сохраняют исходное поведение.
2. Операторы присваивания (=) и взятия адреса (&) автоматически перегружаются для классов с конструкторами копирования или операторами присваивания.
3. Приоритет операторов не меняется; скобки можно использовать для управления порядком.
4. Три оператора — ::, ., ?: — явно запрещены к перегрузке.

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

• Хотя бы один операнд должен быть пользовательским классом.
• Можно перегружать только существующие операторы; новые символы вводить нельзя.
• Некоторые операторы (например, new, delete) нельзя перегружать как friend-функции, но можно как функции-члены.

Как перегрузить оператор

Пример 1: Оператор инкремента

#include <iostream>
using namespace std;
class OperatorOverload {
private:
    int x;
public:
    OperatorOverload() : x(10) {}
    void operator ++() {
        x += 2;
    }
    void Print() {
        cout << "The Count is: " << x;
    }
};
int main() {
    OperatorOverload ov;
    ++ov;
    ov.Print();
    return 0;
}

Вывод:

Скриншот кода:

Разбор кода:

1. Подключаем <iostream> и используем std.
2. Определяем класс OperatorOverload с private int x.
3. Конструктор инициализирует x = 10.
4. Перегружаем префиксный ++ для прибавления 2 к x.
5. Реализуем Print() для вывода обновлённого значения.
6. В main() создаём объект, вызываем перегруженный оператор, печатаем результат.

Пример 2: Сложение комплексных чисел

#include <iostream>
using namespace std;
class TestClass {
private:
    int real, over;
public:
    TestClass(int rl = 0, int ov = 0) : real(rl), over(ov) {}
    TestClass operator + (TestClass const &obj) {
        TestClass result;
        result.real = real + obj.real;
        result.over = over + obj.over;
        return result;
    }
    void print() {
        cout << real << " + i" << over << endl;
    }
};
int main() {
    TestClass c1(9, 5), c2(4, 3);
    TestClass c3 = c1 + c2;
    c3.print();
}

Вывод:

Скриншот кода:

Разбор кода:

1. Подключаем <iostream> и используем std.
2. Определяем TestClass с компонентами real и over.
3. Конструктор для инициализации.
4. Перегружаем + для сложения комплексных чисел.
5. Возвращаем новый TestClass с суммой.
6. Метод print() выводит комплексное число.
7. В main() создаём два экземпляра, складываем, печатаем результат.

Резюме

• Перегрузка операторов позволяет множественные значения для оператора в одной области.
• Даёт пользовательское поведение для пользовательских типов.
• Большинство операторов C++ можно перегрузить, но несколько — нельзя.
• Хотя бы один операнд должен быть пользовательским типом.
• Перегружать можно только существующие операторы.