C++ Operator Supraîncărcare cu exemple

Sintaxă

A supraîncărca a C++ operator, ar trebui să definiți o funcție specială în interiorul clasei după cum urmează:

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

Iată o explicație pentru sintaxa de mai sus:

• Return_type este tipul returnat pentru funcție.
• Apoi, menționați cuvântul cheie operator.
• Simbolul indică simbolul operatorului care trebuie supraîncărcat. De exemplu, +, -, <, ++.
• Argumentele pot fi transmise funcției operator în același mod ca și funcțiile.

Exemplu 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;
}

ieșire:

Iată o captură de ecran a codului:

Explicația codului:

1. Includerea fișierului antet iostream în codul nostru pentru a-i folosi funcțiile.
2. Includeți spațiul de nume std în programul nostru pentru a-i folosi clasele fără a-l apela.
3. Creați o clasă numită TestClass.
4. Utilizați modificatorul de acces privat, care marchează un membru al clasei ca fiind accesibil privat.
5. Creați un număr de variabile întregi. Această variabilă va fi accesibilă în mod privat.
6. Utilizați modificatorul de acces public, care marchează un membru al clasei ca fiind accesibil privat.
7. Utilizați un constructor de clasă pentru a inițializa contorul variabilei la 5.
8. Supraîncărcați semnificația operatorului —.
9. Operatorul va decrementa valoarea variabilei x cu 1.
10. Sfârșitul secțiunii de supraîncărcare a operatorului. Operatorului i s-a dat un nou nume.
11. Definirea unei funcții numită funcție Display().
12. Tipăriți valoarea numărului de variabile alături de alt text de pe consolă atunci când este apelată funcția Display(). } marchează sfârșitul corpului funcției Display().
13. Sfârșitul corpului clasei.
14. Apelați funcția main(). Logica programului ar trebui adăugată în această funcție.
15. Creați o instanță a clasei TestClass și dați-i numele tc.
16. Aceasta va apela funcția operator void –().
17. Utilizați poziția TestClass Class pentru a apela funcția Display().
18. Funcția trebuie să returneze valoarea după finalizarea cu succes.
19. Sfârșitul corpului funcției main().

Diferite abordări ale Operator Supraîncărcarea în C++

Puteți efectua supraîncărcarea operatorului prin implementarea oricăruia dintre următoarele tipuri de funcții:

1. Funcția de membru
2. Funcția non-membru
3. Funcția de prieten

• Funcția de supraîncărcare a operatorului poate fi o funcție membru atunci când un operand Left este un obiect al clasei.
• Când operandul stânga este diferit, Operafuncția de supraîncărcare tor ar trebui să fie o funcție non-membru.

Puteți face ca funcția de supraîncărcare a operatorului să fie o funcție prietenă dacă trebuie să acceseze membrii clasei private și protejate.

Pot toate C++ Operatori să fie supraîncărcat?

Nu. Există C++ operatori care nu pot fi supraîncărcați.

Acestea includ:

• :: -Operator rezolutie domeniul de aplicare
• ?: -operator ternar.
• . -selector de membri
• Dimensiunea operatorului
• * -member pointer selector

Lucruri de reținut

1. Cu supraîncărcarea operatorului, puteți redefini modul în care un operator funcționează numai pentru tipurile definite de utilizator (obiecte, structuri). Nu îl puteți folosi pentru tipurile încorporate (float, char, int etc.).
2. = și & C++ operatorii sunt supraîncărcați în mod implicit. De exemplu, puteți copia obiectele aceleiași clase direct folosind operatorul =.
3. Operaprioritatea tor nu modifică asociativ și prioritatea operatorilor. Cu toate acestea, puteți modifica ordinea evaluării folosind paranteze.
4. Există patru operatori în care nu puteți supraîncărca C++. Acestea includ operatorul de rezoluție a domeniului (::), operatorul de selecție a membrilor (.), selectarea membrilor printr-un indicator către operatorul de funcție (.*) și operatorul ternar (?:).

Reguli pentru Operator Supraîncărcare

Aici sunt reguli pentru Operator Supraîncărcare:

• Pentru ca acesta să funcționeze, cel puțin un operand trebuie să fie un obiect de clasă definit de utilizator.
• Puteți supraîncărca doar operatorii existenți. Nu puteți supraîncărca noi operatori.
• Unii operatori nu pot fi supraîncărcați folosind o funcție prieten. Cu toate acestea, astfel de operatori pot fi supraîncărcați folosind funcția membru.

Cum să supraîncărcați OperaTdR

Exemplu 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;
}

ieșire:

Iată o captură de ecran a codului:

Explicația codului:

1. Includerea fișierului antet iostream în codul nostru pentru a-i folosi funcțiile.
2. Includeți spațiul de nume std în programul nostru pentru a-i folosi clasele fără a-l apela.
3. Creați o clasă numită OperatorSupraîncărcare.
4. Utilizați modificatorul de acces privat, care marchează un membru al clasei ca fiind accesibil privat.
5. Creați o variabilă întreagă x. Această variabilă va fi accesibilă în mod privat.
6. Utilizați modificatorul de acces public, care marchează un membru al clasei ca fiind accesibil privat.
7. Utilizați un constructor de clasă pentru a inițializa variabila x la 10.
8. Supraîncărcați semnificația operatorului ++.
9. Operatorul va crește valoarea variabilei x cu 2.
10. Sfârșitul secțiunii de supraîncărcare a operatorului. Operatorului i s-a dat un nou nume.
11. Apelarea funcției Print().
12. Imprimați valoarea variabilei x alături de alt text pe consolă atunci când este apelată funcția Print().
13. Sfârșitul corpului funcției Print().
14. Sfârșitul corpului clasei.
15. Apelați funcția main(). Logica programului ar trebui adăugată în această funcție.
16. Creați o instanță a OperatorOverload Clasa numită ov.
17. Aceasta va apela funcția operator void ++().
18. Folosește poziția de OperaClasa torOverload pentru a apela funcția Print().
19. Funcția trebuie să returneze valoarea după finalizarea cu succes.
20. Sfârșitul corpului funcției main().

Exemplu 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();
}

ieșire:

Iată o captură de ecran a codului:

Explicația codului:

1. Includerea fișierului antet iostream în programul nostru pentru a utiliza funcțiile acestuia.
2. Includeți spațiul de nume std în programul nostru pentru a utiliza clasele sale fără a-l apela.
3. Creați o clasă numită TestClass. { marchează începutul corpului clasei.
4. Utilizați modificatorul de acces privat pentru a marca variabilele ca private, ceea ce înseamnă că pot fi accesate numai din cadrul clasei.
5. Definiți două variabile întregi, reale și peste.
6. Utilizați modificatorul de acces public pentru a marca constructorul ca public, ceea ce înseamnă că va fi accesibil chiar și în afara clasei.
7. Crearea constructorului de clasă și inițializarea variabile.
8. Inițializați valoarea variabilei real.
9. Inițializați valoarea variabilei peste.
10. Sfârșitul corpului constructorului.
11. Suprascrieți semnificația operatorului +.
12. Creați rezultatul tipului de date de tip TestClass.
13. Utilizați operatorul + cu numere complexe. Această linie va adăuga partea reală a unui număr la partea reală a altui număr.
14. Utilizați operatorul + cu numere complexe. Această linie va adăuga partea imaginară a unui număr la partea imaginară a altui număr.
15. Programul va returna valoarea rezultatului variabilei la executarea cu succes.
16. Sfârșitul definiției noului sens al operatorului +, adică supraîncărcarea.
17. Apelați metoda print().
18. Tipăriți noul număr complex după adăugare pe consolă.
19. Sfârșitul corpului funcției print().
20. Sfârșitul corpului clasei TestClass.
21. Apelarea funcției main().
22. Transmiterea valorilor atât a părților reale, cât și a celor complexe de adăugat. Prima parte a lui c1 va fi adăugată la prima parte a lui c2, adică 9+4. A doua parte a lui c1 va fi adăugată la a doua parte a lui c, adică 5+3.
23. Efectuarea unei operații folosind operatorul supraîncărcat + și stocarea rezultatului în variabila c3.
24. Imprimarea valorii variabilei c3 pe consolă.
25. Sfârșitul corpului funcției main().

Rezumat

• Puteți specifica mai multe semnificații pentru a C++ operator într-un singur domeniu.
• Aceasta se numește supraîncărcare a operatorului.
• Operasupraîncărcarea tor oferă o semnificație specială a unui operator pentru un tip de date definit de utilizator.
• Puteți redefini majoritatea C++ operatori prin suprasolicitarea operatorilor.
• Nu tot C++ operatorii pot fi supraîncărcați.
• Pentru ca un operator să fie supraîncărcat, cel puțin unul dintre operanzi trebuie să fie un obiect definit de utilizator.
• Numai operatorii existenți pot fi supraîncărcați. Nu puteți supraîncărca noi operatori.