Перегрузка оператора 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 - тип возвращаемого значения функции.
оператор - это ключевое слово.
symbol- оператор, который мы хотим перегрузить. Как: +, <, -, ++и т.д.
arguments - аргументы, переданные функции.

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

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

Example1: ++ Оператор (унарный оператор) Перегрузка

 // Overload ++ when used as prefix #include 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; )

Вывод

 Количество: 6

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

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

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

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

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

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

Пример 2: ++ Оператор (унарный оператор) Перегрузка

 // Overload ++ when used as prefix and postfix #include 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; )

Вывод

 Количество: 6 Количество: 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 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; )

Вывод

 Количество: 6 Количество: 7

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

 // 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 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 <> 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:"; complex1.input(); cout << "Enter second complex number:"; complex2.input(); // complex1 calls the operator function // complex2 is passed as an argument to the function result = complex1 + complex2; result.output(); return 0; )

Вывод

 Введите первое комплексное число: введите действительную и мнимую части соответственно: 9 5 Введите второе комплексное число: введите действительную и мнимую части соответственно: 7 6 Выходное комплексное число: 16 + 11i

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

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

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

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

Однако,

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

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

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

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