MyCodeSchool

Pasul 1 din 5

C++

Pasul 1 din 5 · Ce construiești

  • C++
  • Mediu
  • 14 minute

Supraîncărcarea operatorilor în C++

Scrii o clasă Fractie cu care lucrezi ca la matematică: x + y, x * y, x == y și cout << x. Rezultatele ies deja simplificate.

fractii.cpp, în consolă
1/2
1/18
1
3/4

Pentru tipurile tale, operatorii nu există din oficiu. Îi definești tu, ca pe niște funcții cu nume speciale: operator+, operator==, operator<<.

Pasul 2 din 5

Rulează-l linie cu linie

1/2 + 1/3. Urmărește ce se întâmplă de fapt când scrii x + y pentru două fracții.

fractie.cpp
#include <iostream>using namespace std;struct Fractie {    int a, b;    Fractie operator+(Fractie f) {        Fractie r;        r.a = a * f.b + f.a * b;        r.b = b * f.b;        return r;    }};int main() {    Fractie x = {1, 2}, y = {1, 3};    Fractie z = x + y;    cout << z.a << '/' << z.b;    return 0;}

Variabile

Ce apare pe ecran


      

  1. Linia 15. Două fracții, inițializate câmp cu câmp: x = 1/2, y = 1/3.
  2. Linia 16. x + y devine apelul x.operator+(y). Metoda rulează pe x, iar y ajunge în parametrul f.
  3. Linia 7. O fracție nouă pentru rezultat, încă fără valori.
  4. Linia 8. Numărătorul: 1 · 3 + 1 · 2 = 5. a și b fără prefix sunt câmpurile lui x.
  5. Linia 9. Numitorul: 2 · 3 = 6.
  6. Linia 10. Rezultatul se întoarce la apel. x și y au rămas neschimbate.
  7. Linia 16. Fracția 5/6 ajunge în z.
  8. Linia 17. Se afișează câmpurile, separate de /.
  9. Linia 18. main se încheie.
  10. Gata. Operatorul e o funcție obișnuită; doar felul în care o apelezi e mai scurt.

Prezice ieșirea

Schimbi linia 15 în x = {1, 4}, y = {1, 4}. Ce afișează programul?

Răspuns: „8/16”.

1 · 4 + 1 · 4 = 8 și 4 · 4 = 16. Operatorul nu simplifică, așa că 1/2 apare ca 8/16. Programul complet repară asta în constructor.

Pasul 3 din 5

Patru feluri de operatori

Fragmentele 1 și 2 stau în main, sub structura afișată deasupra lor. 3 și 4 sunt programe complete.

Un operator e o metodă cu nume special

struct Fractie
struct Fractie {    int a, b;    Fractie operator+(Fractie f) {        return {a * f.b + f.a * b,                b * f.b};    }};
metoda.cpp
Fractie x = {1, 2}, y = {1, 6};Fractie s1 = x + y;Fractie s2 = x.operator+(y);cout << s1.a << '/' << s1.b << ' ';cout << s2.a << '/' << s2.b;

Ce apare pe ecran

8/12 8/12

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.

Comparații

struct Fractie
struct Fractie {    int a, b;    bool operator==(Fractie f) {        return a * f.b == f.a * b;    }    bool operator<(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.

Afișare cu cout

afisare.cpp
#include <iostream>using namespace 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';    return 0;}

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.

Când întregul e în stânga

stanga.cpp
#include <iostream>using namespace std;struct Fractie {    int a, b;    Fractie operator*(int k) {        return {a * k, b};    }};Fractie operator*(int k,                  Fractie f) {    return f * k;}int main() {    Fractie x = {2, 7};    Fractie p = x * 3, q = 3 * x;    cout << p.a << '/' << p.b;    cout << ' ' << q.a << '/';    cout << q.b;    return 0;}

Ce apare pe ecran

6/7 6/7

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>using namespace std;struct Fractie {    int a, b;};void operator<<(ostream& out,                Fractie f) {    out << f.a << '/' << f.b;}int main() {    Fractie x = {3, 4};    cout << x << '\n';    return 0;}
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>using namespace std;struct Fractie {    int a, b;    Fractie operator+(Fractie f) {        a = a * f.b + f.a * b;        b = b * f.b;        return *this;    }};int main() {    Fractie x = {1, 2}, y = {1, 3};    Fractie z = x + y;    cout << z.a << '/' << z.b;    cout << ' ' << x.a << '/';    cout << x.b;    return 0;}

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>using namespace std;struct Fractie {    int a, b;    bool operator==(Fractie f) {        return a * f.b == f.a * b;    }};int main() {    Fractie x = {2, 4}, y = {1, 2};    Fractie z = {2, 3};    cout << (x == y) << (x == z);    return 0;}

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

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>using namespace std;int cmmdc(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};    }    bool operator==(Fractie f) {        return a == f.a && b == f.b;    }    friend ostream& operator<<(        ostream& out, Fractie f) {        out << f.a << '/' << f.b;        return out;    }};int main() {    Fractie x(1, 6), y(1, 3);    cout << x + y << '\n';    cout << x * y << '\n';    cout << (x + x == y) << '\n';    cout << Fractie(6, 8);    return 0;}

Ce apare pe ecran

1/2
1/18
1
3/4

Continuă cu