Перегрузка оператора C++

В этом руководстве мы узнаем о перегрузке операторов с помощью примеров.

В C++ мы можем изменить способ работы операторов для пользовательских типов, таких как объекты и структуры. Это известно как перегрузка оператора. . Например,

Предположим, мы создали три объекта c1 , c2 и результат из класса с именем Complex который представляет комплексные числа.

Поскольку перегрузка операторов позволяет нам изменить их работу, мы можем переопределить, как + оператор работает и используйте его для сложения комплексных чисел c1 и c2 написав следующий код:

result = c1 + c2;

вместо чего-то вроде

result = c1.addNumbers(c2);

Это делает наш код интуитивно понятным и простым для понимания.

Примечание. Мы не можем использовать перегрузку операторов для основных типов данных, таких как int. , float , char и так далее.

<час>

Синтаксис для перегрузки операторов C++

Чтобы перегрузить оператор, мы используем специальный operator функция. Мы определяем функцию внутри класса или структуры, с объектами/переменными которых мы хотим, чтобы перегруженный оператор работал.

class className {
    ... .. ...
    public
       returnType operator symbol (arguments) {
           ... .. ...
       } 
    ... .. ...
};

Здесь

returnType — возвращаемый тип функции.
operator является ключевым словом.
symbol это оператор, который мы хотим перегрузить. Например:+ , < , - , ++ и т. д.
arguments аргументы, переданные функции.

<час>

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

Унарные операторы работают только с одним операндом. Оператор приращения ++ и оператор декремента -- являются примерами унарных операторов.

<час>

Пример 1. Перегрузка оператора ++ (унарного оператора)

// Overload ++ when used as prefix

#include <iostream>
using namespace std;

class Count {
   private:
    int value;

   public:

    // Constructor to initialize count to 5
    Count() : value(5) {}

    // Overload ++ when used as prefix
    void operator ++ () {
        ++value;
    }

    void display() {
        cout << "Count: " << value << endl;
    }
};

int main() {
    Count count1;

    // Call the "void operator ++ ()" function
    ++count1;

    count1.display();
    return 0;
}

Вывод

Count: 6

Здесь, когда мы используем ++count1; , void operator ++ () называется. Это увеличивает значение атрибут для объекта count1 на 1.

Примечание. Когда мы перегружаем операторы, мы можем использовать их так, как нам нравится. Например, мы могли бы использовать ++ увеличить значение на 100.

Однако это делает наш код запутанным и трудным для понимания. Наша работа как программиста состоит в том, чтобы правильно, последовательно и интуитивно использовать перегрузку операторов.

<час>

Приведенный выше пример работает, только когда ++ используется как префикс. Чтобы сделать ++ в качестве постфикса мы используем этот синтаксис.

void operator ++ (int) {
    // code
}

Обратите внимание на int внутри скобок. Это синтаксис, используемый для использования унарных операторов в качестве постфикса; это не параметр функции.

<час>

Пример 2. Перегрузка оператора ++ (унарного оператора)

// Overload ++ when used as prefix and postfix

#include <iostream>
using namespace std;

class Count {
   private:
    int value;

   public:

    // Constructor to initialize count to 5
    Count() : value(5) {}


    // Overload ++ when used as prefix
    void operator ++ () {
        ++value;
    }


    // Overload ++ when used as postfix
    void operator ++ (int) {
        value++;
    }

    void display() {
        cout << "Count: " << value << endl;
    }
};

int main() {
    Count count1;

    // Call the "void operator ++ (int)" function
    count1++;
    count1.display();

    // Call the "void operator ++ ()" function
    ++count1;

    count1.display();
    return 0;
}

Вывод

Count: 6
Count: 7

<час>

Пример 2 работает, когда ++ используется как префикс и постфикс. Однако это не сработает, если мы попытаемся сделать что-то вроде этого:

Count count1, result;

// Error
result = ++count1;

Это связано с тем, что тип возвращаемого значения нашей операторной функции — void. . Мы можем решить эту проблему, сделав Count как возвращаемый тип операторной функции.

// return Count when ++ used as prefix

Count operator ++ () {
    // code
}

// return Count when ++ used as postfix

Count operator ++ (int) {
   // code
}

<час>

Пример 3. Возвращаемое значение операторной функции (оператор ++)

#include <iostream>
using namespace std;

class Count {
   private:
    int value;

   public
       :
    // Constructor to initialize count to 5
    Count() : value(5) {}

    // Overload ++ when used as prefix
    Count operator ++ () {
        Count temp;

        // Here, value is the value attribute of the calling object
        temp.value = ++value;

        return temp;
    }

    // Overload ++ when used as postfix
    Count operator ++ (int) {
        Count temp;

        // Here, value is the value attribute of the calling object
        temp.value = value++;

        return temp;
    }

    void display() {
        cout << "Count: " << value << endl;
    }
};

int main() {
    Count count1, result;

    // Call the "Count operator ++ ()" function
    result = ++count1;
    result.display();

    // Call the "Count operator ++ (int)" function
    result = count1++;
    result.display();

    return 0;
}

Вывод

Count: 6
Count: 6

Здесь мы использовали следующий код для перегрузки префиксного оператора:

// Overload ++ when used as prefix
Count operator ++ () {
    Count temp;

    // Here, value is the value attribute of the calling object
    temp.value = ++value;

    return temp;
}

Код для перегрузки постфиксного оператора также аналогичен. Обратите внимание, что мы создали объект temp. и вернул его значение операторной функции.

Также обратите внимание на код

temp.value = ++value;

Переменная значение принадлежит count1 объект в main() потому что count1 вызывает функцию, а temp.value принадлежит temp объект.

<час>

Перегрузка оператора в бинарных операторах

Бинарные операторы работают с двумя операндами. Например,

result = num + 9;

Здесь + это бинарный оператор, который работает с операндами num и 9 .

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

obj3 = obj1 + obj2;

Операторная функция вызывается с помощью obj1 объект и obj2 передается в качестве аргумента функции.

<час>

Пример 4. Перегрузка бинарного оператора C++

// C++ program to overload the binary operator +
// This program adds two complex numbers

#include <iostream>
using namespace std;

class Complex {
   private:
    float real;
    float imag;

   public:
    // Constructor to initialize real and imag to 0
    Complex() : real(0), imag(0) {}

    void input() {
        cout << "Enter real and imaginary parts respectively: ";
        cin >> real;
        cin >> imag;
    }

    // Overload the + operator
    Complex operator + (const Complex& obj) {
        Complex temp;
        temp.real = real + obj.real;
        temp.imag = imag + obj.imag;
        return temp;
    }

    void output() {
        if (imag < 0)
            cout << "Output Complex number: " << real << imag << "i";
        else
            cout << "Output Complex number: " << real << "+" << imag << "i";
    }
};

int main() {
    Complex complex1, complex2, result;

    cout << "Enter first complex number:\n";
    complex1.input();

    cout << "Enter second complex number:\n";
    complex2.input();

   // complex1 calls the operator function
   // complex2 is passed as an argument to the function
    result = complex1 + complex2;
    result.output();

    return 0;
}

Вывод

Enter first complex number:
Enter real and imaginary parts respectively: 9 5
Enter second complex number:
Enter real and imaginary parts respectively: 7 6
Output Complex number: 16+11i

В этой программе функция оператора:

Complex operator + (const Complex& obj) {
    // code
}

Вместо этого мы также могли бы написать эту функцию так:

Complex operator + (Complex obj) {
    // code
}

Однако

используя & делает наш код эффективным, ссылаясь на complex2 объект вместо создания дубликата объекта внутри операторной функции.
используя const считается хорошей практикой, поскольку не позволяет операторной функции изменять complex2 .

<рисунок>

<час>

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

Два оператора = и & уже перегружены по умолчанию в C++. Например, для копирования объектов одного класса мы можем напрямую использовать = оператор. Нам не нужно создавать операторную функцию.
Перегрузка операторов не может изменить приоритет и ассоциативность операторов. Однако, если мы хотим изменить порядок оценки, следует использовать круглые скобки.
Есть 4 оператора, которые нельзя перегружать в C++. Они есть:<ол тип="а">
:: (разрешение области)
. (выбор участника)
.* (выбор элемента через указатель на функцию)
?: (тернарный оператор)

<час>

Посетите эти страницы, чтобы узнать больше о:

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

Как передать и вернуть объект из функций С++? Указатели С++

Язык C