Ich habe nun eine ganz leichte Klasse "Zwei" geschrieben, welche nur zwei Integerwerte hat.
Für diese Klasse habe ich einen Operator "operator+" definiert, welcher beide Integerwerte einfach addiert und dann ein "Zwei"-Objekt zurückliefert.
Nun kann ich folgendermaßen vorgehen:

Zwei Z(3,4);
Zwei U(4,5);
Zwei O();
O = Z+U;

Nun hat '0' die Werte 7 und 9.
Soweit so gut.

Blöd wird es, wenn ich die Operatorfunktion explizit aufrufe, was ja auch geht:

O = O.operator+(Z,U);

Im Prinzip sollte das ja haargenau das selbe machen, es funktioniert jedoch nicht, weil 'Z' nun nicht als impliziter Parameter "this" geschluckt wird.

Ich kann also bei dieser Schreibweise nur zu O einen Wert hinzuaddieren, wo ich vorher zwei völlig andere Objekte addieren konnte, deren Ergebnis in O gespeichert wurde.

Zwar ist die obere Schreibweise sowieso besser, mich wundert dennoch, warum die zweitere nicht auch funktioniert.
Ist es einfach so, dass die implizite Schreibweise den ersten der Parameter gleich mit "this" verknüpft, oder wie genau muss ich mir das vorstellen?

cya
David

foo first(1U, 2U);
foo second(3U, 4U);
foo result = first.operator+(second); /* first + second; */// (4U, 6U)

class Zwei 
{
public:
  Zwei& operator+= (Zwei const& rhs)
    { x+=rhs.x; y+=rhs.y; return *this; }
private:
 int x, y;
};

Zwei operator+ (Zwei const& lhs, Zwei const& rhs)
{
  Zwei result(lhs);
  return result += rhs;
}

#include <iostream>
#include <string>
using namespace std;
class Operatoren
{
   private:
      int a;
      int b; 
   public: 
      void seta(int);
      void setb(int);
      int geta(void);
      int getb(void);               
      Operatoren(int c, int d)
      {
         a = c;
         b = d;               
      }
      Operatoren& operator+=(const Operatoren& op)
      {
         a += op.a;
         b += op.b;
         return *this;           
      }
};
void Operatoren::seta(int aa)
{
   a = aa;
}
void Operatoren::setb(int bb)
{
   b = bb;
}
int Operatoren::geta(void)
{
   return a;   
}
int Operatoren::getb(void)
{
   return b;   
}
Operatoren operator+(const Operatoren& op1, const Operatoren& op2)
{
   Operatoren result(op1);
   return (result+=op2);
}
int main(void)
{
   Operatoren O(3,4);
   Operatoren U(7,4);
   Operatoren Z(3,4);
   Operatoren Y(3,4);
   Y = operator+(U,O);
   cout << U.geta() << endl << U.getb() << endl << O.geta() << endl << O.getb() << endl << endl;
   system("Pause");
}

Das ist ein kompletter Funktionierender Quelltext.
Pumukls Tip ist echt nicht schlecht - das funktioniert auch.
Ich habe aber dennoch zu meinem eigenen Quelltext nochmal nen paar Fragen- auch wenn der jetzt funktioniert:

1. Also stimmt es, dass der + Operator am besten niemals Klassenelement ist, da er somit das das eigene Objekt verändert, obwohl der Benutzer der Klasse vielleicht nur wissen möchte, was die zwei Klassen zusammen sind.
Der += Operator sollte aber immer Element der Klasse sein, weil der zum +Operator gehört und es auch nicht schlimm ist, dass er das temporäre Objekt verändert. Die eigentlichen Operanen bleiben ja gleich.

2. Ich habe noch ne allgemeine Frage. Funktionen welche einen Zeiger auf "*this" zurückgeben haben als Rückgabetyp irgendwie immer eine Referenz und keinen Zeiger. Obwohl doch der Rückgabetyp ganz klar ein Zeiger ist. Sobald ich den Rückgabetyp aber auf Zeiger ändere spuckt der Compiler einen Fehler aus
Woran liegt das?

cya
David

Objekt3 = Objekt1 <!> Objekt2

In meinem Buch steht ein Satz, welcher sagt, dass man Operatoren wie == immer verwenden soll, wenn es sinnvoll erscheint ohne eigene erfundene Namen zu nehmen.
Das hiesse ja, dass das Buch davon ausgeht, dass es doch geht nen eigenes Operatorzeichen zu erstellen.

In Pearl geht das ja auch- warum also nicht in C++?
Kann mir darüber noch jemand Klarheit verschaffen?

cya
David

1. Also stimmt es, dass der + Operator am besten niemals Klassenelement ist, da er somit das das eigene Objekt verändert, obwohl der Benutzer der Klasse vielleicht nur wissen möchte, was die zwei Klassen zusammen sind.

So radikal kann man das auch nicht sagen, dass er "niemals" Klassenelement sein darf. Aber es ist im Allgemeinen richtig, dass er außerhalb der Klasse deklariert sein sollte, um mögliche implizite Konvertierungen des ersten Operanden zu erlauben. Das eigene Objekt verändert der operator+ auch als Klassenelement nicht, wenn man ihn richtig definiert und implementiert. Ein operator+ als Klassenelement sollte const sein und muss ein neues Objekt zurückgeben (zeiger wären unintuitiv und Referenzen gehen auch nicht.)

Der += Operator sollte aber immer Element der Klasse sein, weil der zum +Operator gehört und es auch nicht schlimm ist, dass er das temporäre Objekt verändert. Die eigentlichen Operanen bleiben ja gleich.

operator += MUSS meines Wissens immer Element der Klasse sein, einen freien operator+= gibt es nicht. (wäre auch wenig sinnvoll)

777 schrieb:

ochjo- war etwas in die Richtung formuliert, weil da halt stand, 'statt einen Phantasienamen zu nehmen, sollte man gleich ein sinnvolles Zeichen nehmen' oder so.
Aber wenns nicht geht auch okay^^
Thx

Naja, die "sinnvollen" Zeichen gibts ja alle schon - wobei sinnvoll in dem Falle wäre, dass sie bereits bekannt sind und jeder weiß was man damit anfangen kann (weshalb man operatoren nur für die aktionen definieren sollte, die man auch dahinter vermuten würde). Für mich persönlich sieht "<!>" nach einem Phantasie-operator aus, da kann man genausogut eine Funktion mit Phantasienamen nehmen

Etwas OT: Ich hatte mal überlegt, ob es möglich wäre, in C++ den ** -operator aus FORTRAN zu simulieren (Exponentialoperator) Mein bester Ansatz bisher:

class Exponent {
public:
  class Exponentproxy {
    Exponentproxy(double ex) : ex(ex) {}
    double const ex;

    friend Exponent::Exponent(double);
    friend double operator*(double, Exponentproxy const&);
  }

  Exponent(double ex) : proxy(ex) {}
  Exponentproxy const& operator* ()
   {return proxy;}
private:
  Exponentproxy const proxy;
}
double operator*(double lhs, Exponent::Exponentproxy const& rhs)
{
  return pow(lhs, rhs.ex);
}

Sinn der Sache: Die Anwedung des operator* auf einen Exponenten liefert einen Proxy, und die Mutliplikation mit dem Proxy liefert die entsprechende Potenz.
Da im Proxy ALLES private ist, kann nur ein Exponent einen Proxy erstellen und nur der operator* kann auf den Inhalt zugreifen. Der einzige Schönheitsfehler (außer den fehlenden privaten copy-Ctor und op=) den ich biser sehe ist, dass die Compiler leider keine implizite Konvertierung von double nach Exponent vornehmen:

double a,b;
double c = a**b; //FEHLER: b wird nicht implizit in exponent konvertiert
double c = a**Exponent(b); //sollte gehn, aber pow ist kürzer...

Man könnte sowas daher bestenfalls als Spielerei in eine eigene Zahlenklasse einbauen, um den Operator** zu erlauben.

PS: ich habs nicht getestet, wenn jemand große Denkfehler entdeckt bitte melden