C++ Operator Претоварване с примери

Синтаксис

За да претоварите a C++ оператор, трябва да дефинирате специална функция вътре в класа, както следва:

class class_name
{
    ... .. ...
    public
       return_type operator symbol (argument(s))
       {
           ... .. ...
       } 
    ... .. ...
};

Ето обяснение на горния синтаксис:

• return_type е върнатият тип за функцията.
• След това споменавате ключовата дума оператор.
• Символът обозначава символа на оператора, който трябва да бъде претоварен. Например +, -, <, ++.
• Аргументът(ите) могат да бъдат предадени на операторната функция по същия начин като функциите.

Пример 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. Използвайте модификатора за частен достъп, който маркира член на класа като частно достъпен.
5. Създайте целочислена променлива count. Тази променлива ще бъде частно достъпна.
6. Използвайте модификатора за публичен достъп, който маркира член на класа като частно достъпен.
7. Използвайте конструктор на клас, за да инициализирате брояча на променливата до 5.
8. Претоварете значението на оператора —.
9. Операторът ще намали стойността на променливата x с 1.
10. Край на секцията за претоварване на оператора. Операторът получи ново име.
11. Дефиниране на функция с име Display().
12. Отпечатайте стойността на броя на променливите заедно с друг текст на конзолата, когато се извика функцията Display(). } маркира края на тялото на функцията Display().
13. Край на тялото на класа.
14. Извикайте функцията main(). Логиката на програмата трябва да се добави в тази функция.
15. Създайте екземпляр на класа TestClass и му дайте името tc.
16. Това ще извика функцията void operator –().
17. Използвайте позицията на TestClass Class, за да извикате функцията Display().
18. Функцията трябва да върне стойност при успешно завършване.
19. Край на тялото на функцията main().

Различни подходи към Operator Претоварване в C++

Можете да извършите претоварване на оператора, като внедрите някоя от следните типове функции:

1. Членска функция
2. Функция, която не е член
3. Функция приятел

• Функцията за претоварване на оператора може да бъде функция член, когато ляв операнд е обект на класа.
• Когато левият операнд е различен, Operaфункцията за претоварване на tor трябва да е функция, която не е член.

Можете да направите функцията за претоварване на оператора приятелска функция, ако има нужда от достъп до частните и защитените членове на класа.

Може ли всичко C++ Operaда бъдат претоварени?

Не, има C++ оператори, които не могат да бъдат претоварени.

Те включват:

• :: -Оператор за разрешаване на обхват
• ?: -троичен оператор.
• . - селектор на членове
• Оператор sizeof
• * -селектор на указател на член

Какво трябва да запомните

1. С претоварването на оператора можете да предефинирате начина, по който операторът работи само за дефинираните от потребителя типове (обекти, структури). Не можете да го използвате за вградени типове (float, char, int и т.н.).
2. = и & C++ операторите са претоварени по подразбиране. Например, можете да копирате обектите от един и същи клас директно с помощта на оператора =.
3. Operaприоритетът на tor не променя асоциативността и приоритета на операторите. Можете обаче да промените реда на оценяване, като използвате скоби.
4. Има четири оператора, които не можете да претоварвате C++. Те включват оператор за разрешаване на обхват (::), оператор за избор на член (.), избор на член чрез указател към функционален оператор (.*) и троичен оператор (?:).

Правила за Operator Претоварване

Ето правила за Operator Претоварване:

• За да работи, поне един операнд трябва да бъде дефиниран от потребителя клас обект.
• Можете да претоварите само съществуващите оператори. Не можете да претоварвате нови оператори.
• Някои оператори не могат да бъдат претоварени с помощта на функция приятел. Такива оператори обаче могат да бъдат претоварени с помощта на членска функция.

Как да претоварим OperaTor

Пример 1

#include <iostream>   
using namespace std;
class OperatorOverload {
private:
	int x;

public:
	OperatorOverload() : x(10) {}
	void operator ++() {
		x = x + 2;
	}
	void Print() {
		cout << "The Count is: " << x;
		}
};
int main() {
	OperatorOverload ov;
	++ov;   
	ov.Print();
	return 0;
}

Изход:

Ето екранна снимка на кода:

Обяснение на кода:

1. Включване на заглавния файл на iostream в нашия код, за да използваме неговите функции.
2. Включете пространството от имена std в нашата програма, за да използвате неговите класове, без да го извиквате.
3. Създайте клас с име OperatorOverload.
4. Използвайте модификатора за частен достъп, който маркира член на класа като частно достъпен.
5. Създайте целочислена променлива x. Тази променлива ще бъде частно достъпна.
6. Използвайте модификатора за публичен достъп, който маркира член на класа като частно достъпен.
7. Използвайте конструктор на клас, за да инициализирате променлива x до 10.
8. Претоварете значението на оператора ++.
9. Операторът ще увеличи стойността на променливата x с 2.
10. Край на секцията за претоварване на оператора. Операторът получи ново име.
11. Извикване на функцията Print().
12. Отпечатайте стойността на променлива x заедно с друг текст на конзолата, когато се извика функцията Print().
13. Край на тялото на функцията Print().
14. Край на тялото на класа.
15. Извикайте функцията main(). Логиката на програмата трябва да се добави в тази функция.
16. Създайте екземпляр на OperatorOverload Клас с име ov.
17. Това ще извика функцията void operator ++().
18. Използвайте позицията на OperatorOverload клас за извикване на функцията Print().
19. Функцията трябва да върне стойност при успешно завършване.
20. Край на тялото на функцията 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 в нашата програма, за да използваме неговите функции.
2. Включете пространството от имена std в нашата програма, за да използвате неговите класове, без да го извиквате.
3. Създайте клас с име TestClass. { отбелязва началото на тялото на класа.
4. Използвайте модификатора за частен достъп, за да маркирате променливите като частни, което означава, че те могат да бъдат достъпни само от рамките на класа.
5. Дефинирайте две целочислени променливи, real и over.
6. Използвайте модификатора за публичен достъп, за да маркирате конструктора като публичен, което означава, че ще бъде достъпен дори извън класа.
7. Създаване на конструктор на клас и инициализиране на променливи.
8. Инициализирайте стойността на променлива real.
9. Инициализирайте стойността на променливата над.
10. Край на тялото на конструктора.
11. Замени значението на оператора +.
12. Създайте резултат от тип данни от тип TestClass.
13. Използвайте оператора + с комплексни числа. Този ред ще добави реалната част на число към реалната част на друго число.
14. Използвайте оператора + с комплексни числа. Този ред ще добави имагинерната част на число към имагинерната част на друго число.
15. Програмата ще върне стойността на променливата резултат при успешно изпълнение.
16. Край на дефиницията на новото значение на оператора +, тоест претоварване.
17. Извикайте метода print().
18. Отпечатайте новото комплексно число след добавяне на конзолата.
19. Край на тялото на функцията print().
20. Край на тялото на клас TestClass.
21. Извикване на функцията main().
22. Предаване на стойностите както на реални, така и на комплексни части, които трябва да бъдат добавени. Първата част на c1 ще бъде добавена към първата част на c2, тоест 9+4. Втората част на c1 ще бъде добавена към втората част на c, тоест 5+3.
23. Извършване на операция с помощта на претоварения оператор + и съхраняване на резултата в променлива c3.
24. Отпечатване на стойността на променлива c3 на конзолата.
25. Край на тялото на функцията main().

Oбобщение

• Можете да посочите повече от едно значение за a C++ оператор в един обхват.
• Това се нарича претоварване на оператора.
• Operator overloading предоставя специално значение на оператор за дефиниран от потребителя тип данни.
• Можете да предефинирате по-голямата част от C++ оператори чрез претоварване на оператори.
• Не всички C++ операторите могат да бъдат претоварени.
• За да бъде даден оператор претоварен, поне един от операндите трябва да е обект, дефиниран от потребителя.
• Само съществуващите оператори могат да бъдат претоварени. Не можете да претоварвате нови оператори.