Mit Operatoren überladen ist gemeint, wenn man die Funktionsweise von z.B. der +-Funktion für seine Klasse anpasst um sie so intuitiver nutzbar zu machen.

tBruch Bruch;
Bruch = Bruch + 5;
						

Liste der Operatoren

new        +   %   ~   >    /=   |=    <<=   >=   --   ()
delete     -   ^   !   +=   %=   <<    ==    &&   ,    []
new[]      *   &   =   -=   ^=   >>    !=    ||   ->*
delete[]   /   |   <   *=   &=   >>=   <=    ++   ->
						

Beispiel

Bruchrechnung

class tBruch
{
public:
    tBruch() {zaehler=0; nenner=1;}
    int GetNenner()  {return nenner;}
    int GetZaehler()  {return zaehler;}
    void SetNenner(int p) {if (p!=0) nenner=p;}
    void SetZaehler(int p)  {zaehler=p;}
    void Addiere(int);
    void Addiere(tBruch);
    void Show();
private:
    int zaehler;
    int nenner;
};

void tBruch::Addiere(int summand)
{
    zaehler+=summand*nenner;
}

void tBruch::Addiere(tBruch summand)
{
    zaehler = zaehler*summand.GetNenner()
            + summand.GetZaehler()*nenner;
    nenner  = nenner * summand.GetNenner();
}
						

Verwendung

Beispiel anhand der Addition

class tBruch
{
public:
    tBruch() {zaehler=0; nenner=1;}
    int GetNenner()  {return nenner;}
    int GetZaehler()  {return zaehler;}
    void SetNenner(int p) {if (p!=0) nenner=p;}
    void SetZaehler(int p)  {zaehler=p;}
    tBruch operator+(int);
    tBruch operator+(tBruch);
    void Show();
private:
    int zaehler;
    int nenner;
};

tBruch tBruch::operator+(int summand)
{
    zaehler+=summand*nenner;
    return *this;                  // gibt Zeiger zurück
}

tBruch tBruch::operator+(tBruch summand)
{
    zaehler = zaehler*summand.GetNenner()
              + summand.GetZaehler()*nenner;
    nenner  = nenner * summand.GetNenner();
    return *this;
}
						

Aufruf

tBruch Summe, Summand1, Summand2;

Summe = Summand1.operator+(Summand2);
Summe = Summand1 + Summand2;             // identisch zu .operator+
						

Weitere Beispiele

Inkrementieren und Dekrementieren

class tBruch
{
    tBruch& operator++();    // Präfix
    tBruch operator++(int);  // Postfix
    ...
};

tBruch& tBruch::operator++()
// Praefix-Inkrement
{
    // berechne den neuen Bruch
    // geht auch: *this = *this + 1;
    zaehler += nenner;
    return *this;
}

tBruch tBruch::operator++(int)
// Postfix-Inkrement
{
    tBruch oldBruch =*this; // alten Stand sichern
    zaehler += nenner;      // Variable erhöhen
    return oldBruch;        // return alten Stand
}
						

Die Vergleichsoperatoren

// Gleichheitsoperator (kleiner/größer analog)
bool tBruch::operator==(tBruch vgl)
{
    kuerze();
    vgl.kuerze();
    return (zaehler==vgl.zaehler && nenner==vgl.nenner);
}

// Ungleichheit
class tBruch
{
    ...
    bool operator==(tBruch op2);
    bool operator!=(tBruch op2)
        {
            return !(*this == op2);
        }
    ...
};
						

Sonderfall

Global überladen

Besonderheiten auf einen Blick

• können außerhalb einer Klasse verwendet werden
• diese Operatoren können damit nicht überladen werden:
• = Zuweisungsoperator
• () Funktionsaufruf
• [] Index
• -> Zeigeroperator

Beispiel

tBruch tBruch::operator+(int summand);   // globale Funktion

tBruch Buch;
Bruch = Bruch.operator+(5);              // Aufruf
Bruch = Bruch + 5;                       // Aufruf (Alternative)
						

Hier kann auch die friend-Methode helfen

class tBruch
{
    ...
    // die globale Funktion operator+ darf auf
    // Elementvariablen zugreifen
    friend tBruch operator+(int o1, const tBruch& o2);
    ...
};

tBruch operator+(int o1, const tBruch& o2)
{
    tBruch summe;
    summe.zaehler = o2.zaehler+o1*o2.nenner;
    summe.nenner = o2.nenner;
    return summe;
}
						

Noch Fragen?

Vielen Dank!

Weitere Informationen: http://www.willemer.de/informatik/cpp/cppovrld.htm