Supraîncărcarea operatorilor relaționali

În C++ există operatorii relaționali (<, >, <=, >=, ==, !=) folosiți pentru a compara datele de tipuri predefinite (int, double, etc.). Ei pot fi supraîncărcați în contextul claselor, pentru a compara obiecte.

Fiind operatori binari, se aplică regulile prezentate în acest articol, iar rezultatul lor este de tip bool sau întreg: true (1), dacă relatia are loc și false (0) dacă relația nu are loc.

Este interesant de constatat că pentru a compara două date, trebuie precizată explicit numia relația de îndeplinit pentru operația <. Ceilalți operatori relationali pot fi implementați pe baza acesteia.

A < B /// se implementează explicit
A == B     ↔    !(A < B) && !(B < A)
A != B     ↔    (A < B) || (B < A)
A <= B     ↔    A < B || A == B
A > B      ↔    !(A <= B)
A >= B     ↔    !(A < B)

În exemplul de mai jos sunt implementate operatorul < pentru fracții:

• F < G, unde F și G sunt fracții;
• F < n, unde F este fracție, iar n este întreg;
• n < F, unde F este fracție, iar n este întreg.

#include <iostream>

using namespace std;

class Fractie{
    private:
        int numarator, numitor;
    public:
		void afiseaza() /// metodă pentru afișarea fractiei
		{
			cout << numarator << "/" << numitor << endl;
		}
		Fractie(int a = 0, int b = 1) /// constructor
		{
			if(b < 0)
				a = -a, b = -b;
			numarator = a, numitor = b;
		}
		friend bool operator < (Fractie F , Fractie G)
		{	/// metodă, operația F < G
			return F.numarator * G.numitor < F.numitor * G.numarator;
		}
		friend bool operator < (Fractie F , int n)
		{	/// F < n
			return F.numarator * 1 < F.numitor * n;
		}
		friend bool operator < (int n, Fractie F)
		{	/// n < F
			return n * F.numitor < F.numarator * 1;
		}
};

int main(){
	Fractie X(1 , 4), Y(2, 3);
	cout << (X < Y) <<endl;
	cout << (Y < X) <<endl;
	cout << (X < 2) <<endl;
	cout << (2 < X) <<endl;
	return 0;
}

Programul de mai sus va afișa:

1
0
1
0