Wstecz: 18.1 Wstęp W górę: 18. Przeciążanie operatorów Dalej: 18.3 Przeciążenia za pomocą

---

• 18.2.1 Operatory dwuargumentowe
• 18.2.2 Operatory jednoargumentowe

18.2 Przeciążenia za pomocą funkcji globalnych

Operator przeciążać można za pomocą zdefiniowanych globalnie funkcji. Definicja taka wygląda jak normalna definicja funkcji: specjalna jest tylko nazwa tej funkcji. Rozpatrzmy osobno przeciążanie operatorów dwu- i jedno argumentowych.

18.2.1 Operatory dwuargumentowe

Globalną funkcję przeładowującą operator dwuargumentowy definiujemy jako funkcję dwóch argumentów, z których co najmniej jeden musi być typu zdefiniowanego w programie (a nie typu wbudowanego). Nazwą tej funkcji musi być 'operator', gdzie ” jest symbolem operatora, a więc jednym z symboli wymienionych w tabeli operatorów będącym symbolem któregoś z operatorów dwuargumentowych, jak na przykład symbolem ' +' lub '<<'. Zauważmy, że nazwa tej funkcji jest specjalna: po pierwsze słowo ' operator' jest tu słowem kluczowym i musi być tak właśnie napisane, a po drugie symbol nie będący literą, cyfrą lub znakiem podkreślenia normalnie nie byłby dozwolony w identyfikatorze (nazwie) funkcji.

Tak więc deklaracja takiej funkcji ma postać

       Typ operator@(Typ1, Typ2);

Tak zdefiniowaną funkcję można wywołać jawnie, „po nazwie”, ale zwykle się tego nie robi, bo cały sens przeładowywania operatorów polega na tym, by używać tych operatorów zamiast jawnego wywoływania funkcji. Funkcja ta wywołana będzie „samoczynnie”, gdy napotkane będzie wyrażenie

       a @ b

       operator@(a,b)

      1.  #include <iostream>
      2.  using namespace std;
      3.  
      4.  struct Modulo {
      5.      static const int modul;
      6.  
      7.      int numb;
      8.  
      9.      Modulo() : numb(0)
     10.      { }
     11.  
     12.      Modulo(int numb) : numb(numb%modul)
     13.      { }
     14.  };
     15.  const int Modulo::modul = 7;
     16.  
     17.  Modulo operator+(Modulo m, Modulo n) {
     18.      return Modulo(m.numb + n.numb);
     19.  }
     20.  
     21.  int main() {
     22.      Modulo m(5), n(6), k;
     23.  
     24.      k = m + n;
     25.      cout << m.numb << " + " << n.numb
     26.           << " (mod " << Modulo::modul
     27.           << ") = " << k.numb << endl;
     28.  
     29.      k = operator+(m,n);
     30.      cout << m.numb << " + " << n.numb
     31.           << " (mod " << Modulo::modul
     32.           << ") = " << k.numb << endl;
     33.  }

Obiekty tej klasy reprezentują liczby całkowite modulo 7 (każda liczba jest reprezentowana resztą, jaką daje przy dzieleniu przez 7; na przykład 11 i 32 z tego punktu widzenia są równe, bo przy dzieleniu przez 7 dają resztę 4). Istnieje zatem tylko siedem różnych liczb tej klasy [0,..., 6]. Jeśli dodajemy tego rodzaju liczby, to wynik też powinien mieć taką postać; na przykład

W linii 29 widzimy, że jeśli się uprzemy, to możemy naszą funkcję wywołać normalnie, „po nazwie”. W obu przypadkach dostaniemy ten sam rezultat

    5 + 6 (mod 7) = 4
    5 + 6 (mod 7) = 4

W podobny sposób można przeładować inne operatory dwuargumentowe, jak operator dzielenia, reszty z dzielenia, odejmowania itd.

Jednym z najczęściej przeciążanych operatorów jest operator '<<'. Jaki jest typ argumentów tego operatora? Po lewej stronie mamy identyfikator obiektu klasy ostream reprezentującego strumień wyjściowy. Po prawej zaś obiekt typu int, double itd. W tych przypadkach kompilator znajdzie odpowiednią funkcję, bo dla typów wbudowanych są one częścią biblioteki. Jeśli prawym argumentem będzie obiekt typu przez nas zdefiniowanego, to odpowiedniej funkcji nie będzie i wystąpi błąd ... chyba że taką funkcję dostarczymy. Jaki powinien być jej typ zwracany? Jeśli mamy zamiar pisać tylko

       cout << zzz;

       cout << zzz << " " << yyy;

Tak więc, jeśli chcemy „nauczyć” program, jak wypisywać obiekty naszej klasy Klasa do strumienia wyjściowego (związanego z ekranem komputera lub plikiem) za pomocą operatora '<<', powinniśmy zdefiniować funkcję o prototypie

       ostream& operator<<(ostream&, const Klasa&);

Obiekt klasy Klasa (drugi parametr) może być przesłany przez wartość lub referencję. W pierwszym przypadku trzeba zastanowić się, czy potrzebny jest odpowiedni konstruktor kopiujący, aby przekazanie przez wartość (związane z odkładaniem kopii na stosie) miało sens. W drugim przypadku typ parametru nie musi wprawdzie, ale może i najczęściej powinien, być ustalony, bo funkcja będzie miała dostęp do oryginału, a jej zadaniem jest przecież zwykle wypisanie informacji o obiekcie, a nie jego zmiana.

Jeśli przy wypisywaniu informacji o obiekcie potrzebny jest dostęp do prywatnych lub chronionych składowych, to funkcję tę należy też zadeklarować jako zaprzyjaźnioną wewnątrz klasy:

       class Klasa {
           // ...
           friend ostream& operator<<(ostream&, const Klasa&);
       }

Rozpatrzmy zatem przykład:

      1.  #include <iostream>
      2.  #include <string>
      3.  using namespace std;
      4.  
      5.  class Osoba {
      6.      string nazw;
      7.      int    wiek;
      8.  public:
      9.      Osoba(string nazw, int wiek)
     10.          : nazw(nazw), wiek(wiek)
     11.      { }
     12.  
     13.       // ... inne skladowe
     14.  
     15.      friend ostream& operator<<(ostream&, const Osoba&);
     16.  };
     17.  
     18.  ostream& operator<<(ostream& str, const Osoba& k) {
     19.      return str << k.nazw << " (" << k.wiek << " lat)";
     20.  }
     21.  
     22.  int main() {
     23.      Osoba t[] = {  Osoba("Ola",18), Osoba("Ula",26),
     24.                     Osoba("Ala",35), Osoba("Ela",11)  };
     25.  
     26.      for (int i = 0; i < 4; i++)
     27.          cout << t[i] << endl;
     28.  }

W linii 15, wewnątrz definicji klasy Osoba, deklarujemy zaprzyjaźnioną funkcję przeciążającą operator '<<' dla obiektów tej klasy. Dzięki temu funkcja ta, nie będąc składową klasy, będzie miała bezpośredni dostęp do prywatnych składowych nazw i  wiek, o czym przekonuje nas wydruk z tego programu

    Ola (18 lat)
    Ula (26 lat)
    Ala (35 lat)
    Ela (11 lat)

Operator dwuargumentowy możemy przeciążyć tak, aby oba jego argumenty były typu zdefiniowanego przez nas, przy czym każdy z nich może być innego typu. W poniższym przykładzie operator dodawania przeciążony jest tak, aby móc dodawać wektory (obiekty klasy Vector) do wektorów — wynikiem jest wtedy wektor — i wektory do punktów: wynikiem jest wtedy punkt. W tym celu dostarczamy dwóch definicji przeciążonego operatora dodawania: właściwy zostanie wybrany przez kompilator na podstawie typów argumentów dodawania (linie 50 i 53):

      1.  #include <iostream>
      2.  using namespace std;
      3.  
      4.  class Point;
      5.  
      6.  class Vector {
      7.      double x, y, z;
      8.  public:
      9.      Vector(double x = 0, double y = 0, double z = 0)
     10.          : x(x), y(y), z(z)
     11.      { }
     12.      friend Point    operator+(const Point&,  const Vector&);
     13.      friend Vector   operator+(const Vector&, const Vector&);
     14.      friend ostream& operator<<(ostream&, const Vector&);
     15.  };
     16.  
     17.  class Point {
     18.      double x, y, z;
     19.  public:
     20.      Point(double x = 0, double y = 0, double z = 0)
     21.          : x(x), y(y), z(z)
     22.      { }
     23.      friend Point operator+(const Point&, const Vector&);
     24.      friend ostream& operator<<(ostream&, const Point&);
     25.  };
     26.  
     27.  Point operator+(const Point&  p, const Vector& v) {
     28.      return Point(p.x+v.x, p.y+v.y, p.z+v.z);
     29.  }
     30.  
     31.  Vector operator+(const Vector& v1, const Vector& v2) {
     32.      return Vector(v1.x+v2.x, v1.y+v2.y, v1.z+v2.z);
     33.  }
     34.  
     35.  ostream& operator<<(ostream& str, const Point& p) {
     36.      return str << "P(" << p.x << "," << p.y
     37.                 << ","  << p.z << ")";
     38.  }
     39.  
     40.  ostream& operator<<(ostream& str, const Vector& v) {
     41.      return str << "V[" << v.x << "," << v.y
     42.                 << ","  << v.z << "]";
     43.  }
     44.  
     45.  int main() {
     46.  
     47.      Vector v1(1,1,1), v2(2,2,2);
     48.      Point  p1(1,2,3);
     49.  
     50.      Vector v = v1 + v2;
     51.      cout << "v: " << v << endl;
     52.  
     53.      Point  p = p1 + v;
     54.      cout << "p: " << p << endl;
     55.  }

Ponieważ funkcje przeciążające operatory dodawania i wstawiania do strumienia korzystają z bezpośredniego dostępu do prywatnych składowych klas Vector i  Point, zostały w definicji klas zadeklarowane jako zaprzyjaźnione. Zauważmy, że deklaracja zapowiadająca w linii 4 jest tu konieczna, bo w definicji klasy Vector jest używana nazwa Point i odwrotnie. Obie funkcje przeciążające dodawanie zwracają wynik przez wartość; w ten sposób zapewniamy, że wynik nie jest l-wartością: jest to zachowanie, jakiego właśnie spodziewamy się po dodawaniu.

18.2.2 Operatory jednoargumentowe

Analogicznie można przeciążać operatory jednoargumentowe: funkcja (globalna) o prototypie

       Typ operator@(Typarg);

       @a

       operator@(a)

      1.  #include <iostream>
      2.  #include <string>
      3.  using namespace std;
      4.  
      5.  struct AClass {
      6.      string name;
      7.  
      8.      AClass(string name)
      9.          : name(name)
     10.      { }
     11.  };
     12.  
     13.  bool operator!(const AClass& c) {
     14.      return c.name.size() > 5;
     15.  }
     16.  
     17.  int main() {
     18.      AClass t[] = { AClass("Marlon"), AClass("Henry"),
     19.                     AClass("Dave"),   AClass("Horatio"),
     20.                     AClass("Sue"),    AClass("Alice")   };
     21.  
     22.      for (int i = 0; i < 6; ++i)
     23.          if ( !t[i] ) cout << t[i].name << endl;
     24.  }

W linii 23 drukujemy imiona odpowiadające poszczególnym obiektom z tablicy  t; zastosowanie operatora ' !' powoduje, że wydrukowane zostaną tylko te imiona, które liczą ponad pięć liter:

    Marlon
    Horatio

---

Wstecz: 18.1 Wstęp W górę: 18. Przeciążanie operatorów Dalej: 18.3 Przeciążenia za pomocą