Wieso sollte man hier operator+ vorziehen anstatt einfach zu schreiben:

c = a + b ;

Das ist doch viel einfacher und man hat weniger Schreibarbeit.

#include <iostream>

using namespace std;

class complex
{

public:

      double re;

      complex() :
      re(0)
      {}

      complex(double r) :
      re(r)
      {}

      void Ausgabe()
      {
         cout << "re = " << re << endl;
      }
};

complex operator+ ( complex &a,  complex &b)
{
   complex c;
   c.re = a.re  + b.re;
   return c;
}

int main()
{

   complex c;
   complex a(1), b(2) ;

   c = operator+ (a, b);
   c.Ausgabe();

   a=2;
   b=8;

   c = a + b ;
   c.Ausgabe();;

system("PAUSE");
}

Wo hast du diese Idee überhaupt her?

Wann braucht man den diese Operator sachen ?

Wenn ich mir so die Objektorientiere Programmierung angucke denke ich jedes mal wann man was braucht.

Eine Addtion in diesem Fall kann man ja auch über eine Memberfunktion machen was meiner Meinung nach übersichtlicher und leichter ist ...

Eine Addtion in diesem Fall kann man ja auch über eine Memberfunktion machen was meiner Meinung nach übersichtlicher und leichter ist ...

Wenn du meinst, dass das so ist, dann lass es sein. Operatorüberladung "braucht" man nie, es ist nur eine andere Schreibweise für Funktionen. Du musst nur damit rechnen, dass andere Programmierer bei einer complex-Klasse erstmal "a + b" schreiben werden wenn sie "a plus b" meinen anstatt complex::add(a,b), einfach weil man es die übliche Konvention ist.

using namespace std;

class complex 
{

keine gute Idee ist, weil es in der Standardbibliothek eine Klasse std::complex gibt und die Standardheader sich beliebig gegenseitig einbinden dürfen. Das kompiliert mehr oder weniger zufällig.

Was den praktischen Nutzen von Operatorüberladung angeht, es ist in Verbindung mit Templates sehr hilfreich. Einfaches Beispiel:

template<typename T> T square(T const &x) {
  return x * x;
}

// ...

double  d = square(2.0);
complex c = square(complex(1.0, 2.0));

Wenn complex keinen operator* hat, muss ich die Vorlage extra für den Typen spezialisieren, was den Sinn der Funktionsvorlage ad absurdum führt. Mit Operatorüberladung kann ich ein basistypähnliches Interface erwarten und seine Implementation dem Clienttypen überlassen. Das gängigste Beispiel dafür dürften wohl Iteratoren sein, die je nach Iteratorklasse mehr oder weniger das Interface eines Zeigers annähern, was dazu führt, dass alle Vorlagen, die Iteratoren annehmen, auch mit Zeigern umgehen können.

// ohne
newnumber = number.sub(32).mul(5/9)

// mit
newnumber = (number - 32) * (5/9)

Auch schön: Index-Operator für Datenstrukturen, etc.

MfG SideWinder