Претоварване на оператор 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 е аргументите, предадени на функцията.

Претоварване на оператора в унарни оператори

Унарните оператори работят само с един операнд. Операторът на инкремент ++и декремент --са примери за унарни оператори.

Пример1: ++ Оператор (Унар оператор) Претоварване

 // 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 работи, когато ++се използва като префикс, така и Postfix. Въпреки това не работи, ако се опитаме да направим нещо подобно:

 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се счита за добра практика, защото пречи на функцията на оператора да модифицира комплекс2.

Претоварване на двоични оператори в C ++

Неща, които трябва да запомните при претоварване на оператора C ++

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