Frage zum operator+

Hallo wann braucht man eine Operator Überladung ?

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");
}

SeppJ

Du hast Operatorüberladung nicht verstanden. Der Sinn der Sache ist ja gerade, dass man dann c = a + b schreiben kann! Und dann wird der selbstdefinierte Operator genommen. Versuch einmal c = a + b zu schreiben, ohne dass du den Operator definierst und guck was passiert.

Wo hast du diese Idee überhaupt her?

Die Idee is mir einfach so eingefallen. ^^

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 ...

SeppJ

++ schrieb:

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.

Zuerst sollte man sich entscheiden was man möchte.
Dir sagt es nicht zu operator+ (a, b) zu schreiben weil c = a+b einfacher wäre und wenn eine entsprechende Lösung präsentiert wird sind Methoden auf einmal besser da einfacher zu verstehen oO

Ich fühle mich verpflichtet, anzumerken, dass

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.

SideWinder

Ich komme zwar aus der Java-Ecke, aber Operatoren-Überladung kann bis zu einem gewissen Grad schon manchmal nett sein:

// 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