Avansat · POO în C++ · Lecția 3
Supraîncărcarea operatorilor: aritmetică, comparații, <<, >>, [], (), friend
80 minavansat / pregătire pentru facultate și industrie
Înainte de lecția asta: POO.1 Clase de la zero: constructori, liste de inițializare, destructor, RAII, this, const, static, POO.2 Copiere și mutare: constructorul de copiere, operatorul =, semantica mutării, regula lui 0/3/5
Ce vei ști după lecție
- Supraîncarci operatori aritmetici, de comparație, de incrementare și de indexare pentru propriile clase.
- Alegi între operator membru și operator liber (friend) și explici de ce.
- Scrii operator<< și operator>> pentru afișare și citire cu cin/cout.
- Folosești obiecte-funcție (operator()) ca și comparatori pentru sort, set și priority_queue.
- Respecți regulile de bun-simț: semantică naturală, + implementat prin +=, fără surprize.
POO în C++Lecția 3 din 10 · mai sunt 7Urmează: POO.4 · Moștenire și polimorfism: virtual, clase abstracte, vtable, override, destructor virtualVezi toate lecțiile
Cuprins
- De ce operatori?
- Exemplul complet: clasa Fractie
- friend: acces la membrii privați
- << și >>: afișare și citire
- Incrementare: prefix și postfix
- Indexare [] și obiecte-funcție ()
- Operatori pentru olimpiadă: matrice și ridicare la putere
- Reguli de bun-simț
- Greșeli frecvente
- Exersează pe hârtie
- Mini-grile
- Mai departe (pentru cine vrea mai mult)
- Rezumat
- Citește și exersează în plus
- Răspunsuri
Fișiere PDF și de lucru
- Lecția în PDF
versiunea de printat
1. De ce operatori?
Pentru int scrii a + b * c. Pentru o clasă Fractie ai putea scrie a.aduna(b.inmulteste(c)), dar e greu de citit. Supraîncărcarea operatorilor îți permite să dai sens operatorilor obișnuiți pentru tipurile tale: a + b * c funcționează și pentru fracții, numere mari, vectori geometrici, matrice. Așa sunt făcute și clasele din biblioteca standard: string are + și ==, cout are <<, vector are [].
Un operator este, de fapt, o funcție cu un nume special:
| Scrii | Compilatorul înțelege (membru) | sau (funcție liberă) |
|---|---|---|
a + b |
a.operator+(b) |
operator+(a, b) |
a += b |
a.operator+=(b) |
operator+=(a, b) |
-a |
a.operator-() |
operator-(a) |
cout << a |
– (nu putem modifica clasa ostream) |
operator<<(cout, a) |
v[i] |
v.operator[](i) |
– (doar membru) |
f(x, y) |
f.operator()(x, y) |
– (doar membru) |
2. Exemplul complet: clasa Fractie
Clasa păstrează un invariant: fracția este ireductibilă, iar numitorul este pozitiv. Fiecare operație se termină cu simplifica(), deci invariantul nu se strică niciodată, iar comparația == se reduce la compararea a două numere.
#include <iostream>
#include <numeric>
#include <stdexcept>
using namespace std;
class Fractie
{
long long a, b; // invariant: b > 0, cmmdc(|a|, b) = 1
void simplifica()
{
if (b == 0) throw invalid_argument("numitor 0");
if (b < 0) { a = -a; b = -b; }
long long d = gcd(a < 0 ? -a : a, b);
if (d > 1) { a /= d; b /= d; }
}
public:
Fractie(long long x = 0, long long y = 1) : a(x), b(y) { simplifica(); }
Fractie& operator+=(const Fractie &f) { a = a * f.b + f.a * b; b *= f.b; simplifica(); return *this; }
Fractie& operator-=(const Fractie &f) { a = a * f.b - f.a * b; b *= f.b; simplifica(); return *this; }
Fractie& operator*=(const Fractie &f) { a *= f.a; b *= f.b; simplifica(); return *this; }
Fractie& operator/=(const Fractie &f) { a *= f.b; b *= f.a; simplifica(); return *this; }
Fractie operator-() const { return Fractie(-a, b); } // minus unar
Fractie& operator++() { a += b; return *this; } // ++f (prefix)
Fractie operator++(int) { Fractie vechi = *this; a += b; return vechi; } // f++ (postfix)
friend Fractie operator+(Fractie x, const Fractie &y) { return x += y; }
friend Fractie operator-(Fractie x, const Fractie &y) { return x -= y; }
friend Fractie operator*(Fractie x, const Fractie &y) { return x *= y; }
friend Fractie operator/(Fractie x, const Fractie &y) { return x /= y; }
friend bool operator==(const Fractie &x, const Fractie &y) { return x.a == y.a && x.b == y.b; }
friend bool operator!=(const Fractie &x, const Fractie &y) { return !(x == y); }
friend bool operator<(const Fractie &x, const Fractie &y) { return x.a * y.b < y.a * x.b; }
friend ostream& operator<<(ostream &out, const Fractie &f)
{
out << f.a;
if (f.b != 1) out << '/' << f.b;
return out;
}
friend istream& operator>>(istream &in, Fractie &f)
{
long long x, y;
if (in >> x >> y) f = Fractie(x, y);
return in;
}
};
int main()
{
Fractie p, q;
cin >> p >> q;
cout << p << " + " << q << " = " << p + q << '\n';
cout << p << " - " << q << " = " << p - q << '\n';
cout << p << " * " << q << " = " << p * q << '\n';
cout << p << " / " << q << " = " << p / q << '\n';
cout << (p < q ? "p < q" : (p == q ? "p = q" : "p > q")) << '\n';
Fractie r = p++;
cout << r << ' ' << p << ' ' << -p + 1 << '\n';
return 0;
}Pe intrarea -4 6 2 -3, constructorul aduce ambele fracții la -2/3 (numitorul devine pozitiv, apoi se simplifică), deci p == q.
De ce așa?
De ce += ca membru și + ca funcție liberă? += modifică obiectul din stânga, deci este natural să fie membru și să întoarcă *this prin referință. + creează un obiect nou și nu modifică operanzii: îl scriem o singură dată, prin += (primește x prin valoare, deci o copie, îl modifică și îl întoarce). Așa nu duplicăm formula. De ce liber și nu membru? Ca să meargă și 1 + f: un operator membru cere ca operandul din stânga să fie deja Fractie; unul liber permite conversia implicită a lui 1 în Fractie(1) prin constructor, pe oricare parte.
3. friend: acces la membrii privați
O funcție declarată friend în interiorul clasei nu este membră (nu are this), dar are voie să citească membrii private. Este exact ce trebuie pentru operator<<, operator+ sau operator==, care au nevoie de a și b, dar nu pot fi membri (sau nu e bine să fie).
De știut
friend nu strică încapsularea dacă o folosești cu măsură: funcția prietenă face parte din interfața clasei, este declarată chiar în clasă și o scrie tot autorul clasei. Ce trebuie evitat este să faci prietene clase întregi doar ca să ocolești private.
4. << și >>: afișare și citire
friend ostream& operator<<(ostream &out, const Fractie &f); // cout << f
friend istream& operator>>(istream &in, Fractie &f); // cin >> f- Primul parametru este fluxul (
cout, unofstream, unstringstream): prin referință, fiindcă fluxurile nu se pot copia. - Întorc fluxul prin referință, ca să meargă înlănțuirea:
cout << a << " " << bînseamnăoperator<<(operator<<(operator<<(cout, a), " "), b). - La
>>, obiectul se primește prin referință ne-constantă (îl modificăm), iar dacă citirea eșuează nu atingem obiectul.
5. Incrementare: prefix și postfix
| Forma | Semnătura | Întoarce |
|---|---|---|
++f (prefix) |
T& operator++() |
obiectul după incrementare, prin referință |
f++ (postfix) |
T operator++(int) |
o copie a valorii vechi |
Parametrul int din postfix nu se folosește: este doar un semn care deosebește cele două forme. Postfixul face o copie în plus; de aceea, în bucle, ++it este preferat lui it++ pentru iteratori și obiecte mari.
6. Indexare [] și obiecte-funcție ()
Operatorul []
Se scrie în două variante: una care permite modificarea (v[i] = 5) și una const, pentru obiecte constante:
int& operator[](int i) { return p[i]; } // pentru v[i] = 5
const int& operator[](int i) const { return p[i]; } // pentru citire dintr-un obiect constOperatorul (): obiecte-funcție (functori)
O clasă cu operator() se poate „apela” ca o funcție, dar spre deosebire de o funcție poate ține stare (de exemplu, un prag ales la rulare). Biblioteca standard le folosește peste tot ca comparatori.
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
using namespace std;
struct Elev
{
string nume;
int nota;
};
struct DupaNota // obiect-funcție: compară după notă, descrescător
{
bool operator()(const Elev &x, const Elev &y) const
{
if (x.nota != y.nota) return x.nota > y.nota;
return x.nume < y.nume;
}
};
class PesteMedie // obiect-funcție cu stare: pragul este ales la rulare
{
int prag;
public:
explicit PesteMedie(int p) : prag(p) {}
bool operator()(const Elev &e) const { return e.nota >= prag; }
};
int main()
{
int n, prag;
cin >> n >> prag;
vector<Elev> v(n);
for (auto &e : v) cin >> e.nume >> e.nota;
sort(v.begin(), v.end(), DupaNota()); // comparatorul este un obiect
for (int i = 0; i < 3 && i < n; i++) cout << v[i].nume << ' ' << v[i].nota << '\n';
cout << count_if(v.begin(), v.end(), PesteMedie(prag)); // câți au cel puțin pragul
return 0;
}Sfat
Același comparator se poate da unui set sau unui priority_queue ca parametru de tip: set<Elev, DupaNota> s;. O lambda (lecția oop-07) este, de fapt, un obiect-funcție scris pe scurt, generat de compilator.
7. Operatori pentru olimpiadă: matrice și ridicare la putere
Cu operator* pentru matrice și ridicarea la putere rapidă (lecția co-09), termenul n al șirului lui Fibonacci se obține în O(log n): [[1,1],[1,0]]ⁿ conține F(n) pe poziția din dreapta-sus.
#include <iostream>
using namespace std;
struct Mat2
{
long long m[2][2];
Mat2 operator*(const Mat2 &o) const // produs de matrice 2 × 2
{
Mat2 r{};
for (int i = 0; i < 2; i++)
for (int j = 0; j < 2; j++)
for (int k = 0; k < 2; k++)
r.m[i][j] += m[i][k] * o.m[k][j];
return r;
}
};
Mat2 putere(Mat2 a, long long n) // a^n, același algoritm ca la numere
{
Mat2 r{{{1, 0}, {0, 1}}}; // matricea unitate
while (n > 0)
{
if (n & 1) r = r * a;
a = a * a;
n >>= 1;
}
return r;
}
int main()
{
long long n;
cin >> n;
Mat2 q{{{1, 1}, {1, 0}}};
cout << putere(q, n).m[0][1]; // F(n)
return 0;
}De ce așa?
De ce funcționează același algoritm? Ridicarea la putere rapidă cere doar ca înmulțirea să fie asociativă, iar înmulțirea matricelor este. Supraîncărcând *, funcția putere arată exact ca pentru numere. Aceasta este puterea operatorilor: algoritmii generali funcționează pe tipurile tale (iar cu șabloane, lecția oop-06, poți scrie putere o singură dată pentru orice tip).
8. Reguli de bun-simț
| Regula | De ce |
|---|---|
păstrează sensul natural (+ adună, == compară) |
cine citește codul se așteaptă la asta |
implementează + prin +=, != prin ==, > prin < |
o singură formulă, fără contradicții |
operatorii care modifică întorc T&, cei care creează valori întorc T |
se comportă ca la tipurile predefinite |
| comparațiile și aritmetica simetrică: funcții libere | conversiile funcționează pe ambele părți |
=, [], (), ->: obligatoriu membri |
regula limbajului |
nu supraîncărca &&, ||, , |
își pierd evaluarea scurtcircuitată / ordinea |
operatorii de conversie: explicit operator bool() const |
evită conversii surprinzătoare |
De știut
În C++20 operatorul „navă spațială” <=> poate genera automat toate cele șase comparații (auto operator<=>(const T&) const = default;). În lecții folosim C++17, de aceea le-am scris de mână; în proiecte noi, <=> scurtează mult codul.
9. Greșeli frecvente
| Greșeala | Ce se întâmplă | Corect |
|---|---|---|
operator<< membru al clasei |
trebuie scris f << cout, invers |
funcție liberă (friend) |
operator<< care întoarce void |
cout << a << b nu se compilează |
întoarce ostream& |
operator+ care modifică operandul stâng |
c = a + b schimbă și a |
+ întoarce o valoare nouă |
+= care întoarce o copie |
(a += b) += c nu modifică a de două ori |
întoarce T& |
lipsește varianta const a lui [] |
nu se poate citi dintr-un obiect const |
două variante |
comparator <= dat lui sort |
comportament nedefinit (ordine strictă cerută) | < strict |
== scris independent de < cu altă logică |
rezultate contradictorii | aceeași definiție de bază |
depășire în a * f.b la fracții mari |
rezultat greșit | simplificare înainte, __int128 sau numere mari |
10. Exersează pe hârtie
1. Ce funcție apelează compilatorul pentru a + b, a += b, -a, cout << a, dacă + este liber și +=, - sunt membri?
2. De ce 1 + Fractie(1, 2) funcționează cu operator+ liber, dar nu cu operator+ membru?
3. Ce întoarce ++f și ce întoarce f++? Ce afișează: Fractie f(1, 2); cout << f++ << ' ' << ++f;?
4. Scrie operator-= pentru o clasă Vector2D { double x, y; } și apoi operator- prin el.
5. De ce operator<< întoarce ostream&?
6. Pentru Fractie(6, -8), ce valori au a și b după construire?
7. Scrie un functor ModuloK cu un membru k care întoarce x % k == 0. Cum îl folosești cu count_if?
8. Ce face Mat2 r{}; și de ce este important în operator*?
9. De ce comparatorul pentru sort trebuie să fie strict (<, nu <=)?
10. Ce operator ai supraîncărca pentru a putea scrie if (f) cu sensul „fracția nu este zero”? Cum îl faci să nu permită int x = f;?
11. Mini-grile
1. operator<< pentru afișare se scrie ca:
a) metodă a clasei b) funcție liberă, de obicei friend c) metodă a lui ostream d) operator static
2. Postfixul f++ are semnătura:
a) T& operator++() b) T operator++(int) c) void operator++() d) T operator+(int)
3. Care operator nu se recomandă a fi supraîncărcat?
a) + b) [] c) && d) ==
4. Un obiect-funcție este:
a) un pointer la funcție b) un obiect al unei clase cu operator() c) o funcție statică d) o funcție friend
12. Mai departe (pentru cine vrea mai mult)
<=>(C++20) și comparațiile generate automat.- Literali definiți de utilizator:
3_kg,"abc"s. - Numere mari (adunare, înmulțire pe cifre) cu operatori: aplicație clasică la olimpiadă.
operator->șioperator*pentru clase care se comportă ca pointeri (smart pointers, iteratori).- Expression templates: cum fac bibliotecile de matrice
a + b + cfără temporare.
Rezumat
- Un operator este o funcție cu nume special (
operator+); îl poți scrie ca membru sau ca funcție liberă. +=,-=,++,[],()ca membri;+,-,==,<,<<,>>ca funcții libere (adeseafriend).+se implementează prin+=; operatorii care modifică întorcT&, ceilalțiT.<<și>>primesc fluxul prin referință și îl întorc, pentru înlănțuire.- Obiectele-funcție (
operator()) sunt comparatori cu stare pentrusort,set,priority_queue. - Păstrează sensul natural al operatorilor; nu supraîncărca
&&,||,,.
Citește și exersează în plus
- cppreference — operator overloading · en.cppreference.com
toate formele canonice ale operatorilor (engleză)
https://en.cppreference.com/w/cpp/language/operators
- learncpp.com — Introduction to operator overloading · learncpp.com
capitolul complet, cu exerciții (engleză)
https://www.learncpp.com/cpp-tutorial/introduction-to-operator-overloading/
- C++ Core Guidelines — Operators · isocpp.github.io
reguli pentru operatori supraîncărcați (engleză)
https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#Ro-overload
Te-ai blocat la lecția asta?
Scrie-mi ce nu iese și vedem împreună de unde se blochează.
Răspunsuri
Exersează pe hârtie
1. operator+(a, b); a.operator+=(b); a.operator-(); operator<<(cout, a).
2. La un operator membru, operandul stâng trebuie să fie deja Fractie (1.operator+(…) nu există). La funcția liberă, 1 se convertește prin constructorul Fractie(1), care nu este explicit.
3. ++f întoarce obiectul incrementat, prin referință; f++ întoarce o copie a valorii vechi. Afișează 1/2 5/2 (f++ dă 1/2 și face f = 3/2; ++f face f = 5/2).
4. Vector2D& operator-=(const Vector2D &o) { x -= o.x; y -= o.y; return *this; } și Vector2D operator-(Vector2D a, const Vector2D &b) { return a -= b; }.
5. Ca să poată fi înlănțuit: rezultatul lui cout << a este din nou cout, la care se aplică << b.
6. Numitorul negativ: a = -6, b = 8; cmmdc 2: a = -3, b = 4.
7. struct ModuloK { int k; bool operator()(int x) const { return x % k == 0; } }; și count_if(v.begin(), v.end(), ModuloK{3}).
8. Inițializează toate elementele cu 0. Fără el, r.m[i][j] += … ar aduna la valori nedefinite.
9. Algoritmii de sortare presupun o „ordine strictă slabă”: un element nu este mai mic decât el însuși. Cu <=, x <= x este adevărat și algoritmul poate citi în afara vectorului sau intra în buclă.
10. explicit operator bool() const { return a != 0; }. Cu explicit, if (f) funcționează (context boolean), dar int x = f; nu se compilează.
Mini-grile
1. b). 2. b). 3. c) &&. 4. b).