Cele două linii sunt echivalente: x + y e doar o scriere scurtă pentru x.operator+(y). Operandul din stânga e obiectul, cel din dreapta e parametrul.
2
Comparații
struct Fractie
struct Fractie {int a, b;booloperator==(Fractie f) {return a * f.b == f.a * b; }booloperator<(Fractie f) {return a * f.b < f.a * b; }};
comparatii.cpp
Fractie x = {1, 2}, y = {3, 6};Fractie z = {2, 3};cout << (x == y) << ' ';cout << (x < z) << ' ';cout << (z < x);
Ce apare pe ecran
1 1 0
Operatorii de comparație întorc bool. 1/2 și 3/6 au câmpuri diferite, dar sunt egale ca fracții: compari produsele în cruce, 1 · 6 și 3 · 2. Cu operator< definit, poți sorta fracții.
3
Afișare cu cout
afisare.cpp
#include<iostream>usingnamespace std;struct Fractie {int a, b;};ostream& operator<<(ostream& out, Fractie f) { out << f.a << '/' << f.b;return out;}int main() { Fractie x = {3, 4}, y = {5, 2}; cout << x << ' ' << y << '\n';return0;}
Ce apare pe ecran
3/4 5/2
În cout << x, operandul din stânga e cout, de tip ostream, nu fracția ta. De aceea operatorul e o funcție în afara clasei, cu doi parametri. Întoarce out, ca să poți continua lanțul: << ' ' << y.
x * 3 folosește metoda. 3 * x ar însemna 3.operator*(x), iar un int nu are metode. Pentru el scrii o funcție liberă, care refolosește metoda. Dacă funcția are nevoie de câmpuri private, o declari friend în clasă, ca în programul complet.
Capcană: operator<< care nu întoarce nimic
Cu void, cout << x merge singur, dar lanțul se rupe la următorul <<:
void.cpp
#include<iostream>usingnamespace std;struct Fractie {int a, b;};voidoperator<<(ostream& out, Fractie f) { out << f.a << '/' << f.b;}int main() { Fractie x = {3, 4}; cout << x << '\n';return0;}
void.cpp: In function 'int main()':
void.cpp:15:15: error: invalid operands of types 'void' and 'char' to binary 'operator<<'
15 | cout << x << '\n';
Repară cu ostream& ca tip întors și return out; la final.
Capcană: + care strică operandul
Operatorul scrie direct în a și b, câmpurile lui x. Suma iese bine, dar x s-a schimbat:
modifica.cpp
#include<iostream>usingnamespace std;struct Fractie {int a, b; Fractie operator+(Fractie f) { a = a * f.b + f.a * b; b = b * f.b;return *this; }};intmain() { Fractie x = {1, 2}, y = {1, 3}; Fractie z = x + y; cout << z.a << '/' << z.b; cout << ' ' << x.a << '/'; cout << x.b;return0;}
Ce apare pe ecran
5/6 5/6
x trebuia să rămână 1/2. Repară construind rezultatul într-o fracție nouă, ca la pasul 2. Comportamentul ăsta e treaba lui +=, nu a lui +.
Pasul 4 din 5
Verifică-te
Cinci întrebări noi. După fiecare răspuns vezi imediat de ce e așa.
1 din 5 · Alege varianta
operator+ e o metodă a clasei Fractie. În ce se traduce x + y?
Răspuns: x.operator+(y).
Operandul din stânga e obiectul pe care se apelează metoda. Forma cu doi parametri e cea pentru funcțiile libere, ca la 3 * x.
2 din 5 · Prezice ieșirea
Ce afișează programul?
egal.cpp
#include<iostream>usingnamespace std;struct Fractie {int a, b;booloperator==(Fractie f) {return a * f.b == f.a * b; }};intmain() { Fractie x = {2, 4}, y = {1, 2}; Fractie z = {2, 3}; cout << (x == y) << (x == z);return0;}
Răspuns: „10”.
2 · 2 = 1 · 4, deci 2/4 == 1/2 e adevărat și se afișează 1. 2 · 3 nu e egal cu 2 · 4, deci a doua comparație dă 0.
3 din 5 · Alege varianta
De ce operator<< întoarce ostream&?
Răspuns: pentru lanț.
cout << x << y înseamnă (cout << x) << y. Prima parte trebuie să întoarcă tot fluxul, ca a doua să aibă în stânga un ostream.
4 din 5 · Alege varianta
Ai doar metoda Fractie operator*(int k). Ce se întâmplă la 3 * x?
Răspuns: eroare de compilare.
C++ nu presupune că înmulțirea e comutativă pentru tipul tău. Ai nevoie de funcția liberă operator*(int, Fractie), ca în cardul 4.
5 din 5 · Alege varianta
Care operator NU poate fi supraîncărcat?
Răspuns: punctul.
Nu se pot supraîncărca ., ::, ?: și sizeof. [] se supraîncarcă des, de exemplu la clase de tip vector.
Pasul 5 din 5
Ce ai învățat
x + y înseamnă x.operator+(y): obiectul e în stânga, parametrul în dreapta.
Operatorii de comparație întorc bool. La fracții, egalitatea se verifică în cruce sau după simplificare.
operator<< e funcție liberă, primește ostream& și îl întoarce, pentru lanț.
Când operandul din stânga nu e clasa ta, scrii o funcție liberă sau friend.
Programul complet
Constructorul simplifică fiecare fracție cu cmmdc, așa că rezultatele ies mereu ireductibile, iar == poate compara direct câmpurile. operator<< e friend, pentru că a și b sunt private.
fractii.cpp
#include<iostream>usingnamespace std;intcmmdc(int x, int y) {while (y != 0) {int r = x % y; x = y; y = r; }return x;}class Fractie {int a, b;public: Fractie(int x, int y) {int d = cmmdc(x, y); a = x / d; b = y / d; } Fractie operator+(Fractie f) {int x = a * f.b + f.a * b;return {x, b * f.b}; } Fractie operator*(Fractie f) {return {a * f.a, b * f.b}; }booloperator==(Fractie f) {return a == f.a && b == f.b; }friend ostream& operator<<( ostream& out, Fractie f) { out << f.a << '/' << f.b;return out; }};intmain() { Fractie x(1, 6), y(1, 3); cout << x + y << '\n'; cout << x * y << '\n'; cout << (x + x == y) << '\n'; cout << Fractie(6, 8);return0;}