Supraîncărcarea operatorilor de incrementare/decrementare

Operatorii de incrementare (++) și decrementare (--) sunt unari, deoarece se aplică la un singur operand. Ei sunt totuși speciali, deoarece:

• pot fi prefixați (++ X) sau postfixați (X ++);
• efectul este modificare obiectului curent (de exemplul mărirea cu 1 sau altă modificare, în funcție de specificul clasei pentru care îi definim);
• rezultatul diferă:
  • pentru operatorul prefixat, rezultatul este obiectul curent, după modificare;
  • pentru operatorul postfixat, rezultatul este o copie a obiectului curent, înainte de modificare.

Implementarea se realizează astfel, ca metodă:

• pentru operatorul prefixat se utilizează o metodă fără parametri, care modifică obiectul curent și returnează o referință la acesta;
• pentru operatorul postfixat se utilizează, prin convenție, o metodă cu un parametru, de tip int; metoda modifică obiectul curent și returnează o copie a acestuia, realizață înainte de modificare.

Programul de mai jos supraîncarcă operatorii de preincrementare și postincrementare pentru clasa Fracție. Operațiile de decrementare se pot realiza similar.

#include <iostream>

using namespace std;

class Fractie{
    private:
        int numarator, numitor;
    public:
		Fractie(int a = 0, int b = 1) /// constructor
		{
			if(b < 0)
				a = -a, b = -b;
			numarator = a, numitor = b;
		}

		friend ostream & operator << (ostream & out , const Fractie & F)
		{
			out << F.numarator << "/" << F.numitor;
			return out;
		}
		// incrementare prefixata
		Fractie & operator ++()
		{
			numarator += numitor;
			return * this;
		}

        // incrementare postfixata
		Fractie operator ++(int)
		{
			Fractie tmp = Fractie(numarator , numitor);
			numarator += numitor;
			return tmp;
		}
};

int main(){
	Fractie X , Y;
	Y = Fractie(1 , 2);
	X = Y ++;
	cout << X << " " << Y << endl; // 1/2 3/2

	Y = Fractie(1 , 2);
	X = ++ Y;
	cout << X << " " << Y << endl; // 3/2 3/2

	return 0;
}

Observație: Operatorii ++ și -- pot fi implemntați și ca funcții prietene. Exemplu:

#include <iostream>

using namespace std;

class Fractie{
	private:
		int numarator, numitor;
	public:
		Fractie(int a = 0, int b = 1) /// constructor
		{
			if(b < 0)
				a = -a, b = -b;
			numarator = a, numitor = b;
		}

		friend ostream & operator << (ostream & out , const Fractie & F)
		{
			out << F.numarator << "/" << F.numitor;
			return out;
		}
		// incrementare prefixata
		friend Fractie & operator ++(Fractie & F)
		{
			F.numarator += F.numitor;
			return F;
		}

		// incrementare postfixata
		friend Fractie operator ++(Fractie & F, int)
		{
			Fractie tmp = Fractie(F.numarator , F.numitor);
			F.numarator += F.numitor;
			return tmp;
		}
};

int main(){
	Fractie X , Y;
	Y = Fractie(1 , 2);
	X = Y ++;
	cout << X << " " << Y << endl; // 1/2 3/2

	Y = Fractie(1 , 2);
	X = ++ Y;
	cout << X << " " << Y << endl; // 3/2 3/2

	return 0;
}

In cazul implementării prin funcții prietene, parametrul obiect trebuie tranmis prin referință, pentru a se întoarce din funcție modificat.