ich bin relativ neu mit C++ und verzweifle an folgendem Problem:
Bin dabei, mir eine Klasse namens matrix fuer komplexe Matrizen zu schreiben.
Dazu muss ich in der Klasse die Operatoren +,= etc. ueberladen. Hab die mal so definiert:

matrix operator+(matrix&);[code]
void operator=(matrix*);

und dann so implementiert:

matrix matrix::operator+(matrix &M)
{
   matrix C = matrix(dim);
   for (char i=0; i<dim; i++)
   {
      for (char j=0; j<dim; j++)
      {
         (C).set(get(i,j)+M.get(i,j),i,j);
      };
   };
   return (C);	
};

void matrix::operator=(matrix* M)
{
   for (char i=0; i<dim; i++)
   {
      for(char j=0; j<dim; j++)
      {
	 set((*M).get(i,j),i,j);
      };
   };
};

(set und get setzen bzw. liefern das entsprechende Matrixelement).
Nun das Problem:

matrix A;
matrix B;
matrix C;
A+B;               //funktioniert
A=B;               //funktioniert
A = B+C;      //funktioniert nicht!

Bei der letzten Zeile kommt vom Compiler der Fehler, dass der "="-Operator mit dem Argument nicht definiert ist.
Funktionieren tut es, wenn ich fuer den "+"-Operatoren matrix& als Rueckgabe-Typ verwende:

matrix& matrix::operator+(matrix &M)
{
   matrix* C = new matrix(dim);
   for (char i=0; i<dim; i++)
   {
      for (char j=0; j<dim; j++)
      {
         (*C).set(get(i,j)+M.get(i,j),i,j);
      };
   };
   return *C;	
};

In dem Fall habe ich aber das Problem, dass ich mit new eine neue Matrix anlegen
muss, die nicht mehr geloescht wird. Das fuehrt in meinem Programm, fuer die
die Klasse benoetigt wird, recht schnell dazu, dass der Speicher ueberlaeuft

Waere toll wenn mir irgendjemand einen Tip haette, bin echt am Verzweifeln, so langsam...

Gruß, Fabian

void matrix::operator=(matrix& M)
{
   for (char i=0; i<dim; i++)
   {
      for(char j=0; j<dim; j++)
      {
         set(M.get(i,j),i,j);
      };
   };
};

Gruß, Fabian

1. Copy-Konstruktor überladen (sowieso wichtig!)

2. += Operator überladen, das würde dann so aussehen

matrix& matrix::operator+=(const matrix& rhs)
     {
        // addiere rhs zu "this"
        return *this;
     }

3. Zuweisungs(=) Operator überladen

matrix& matrix::operator=(const matrix &rhs) {

    //hier zuerst auf Selbstzuweisung prüfen
    if (this != &rhs) {
     // hier wird die Kopierlogik implementiert, wobei 
     // hier auch das Löschen des Heaps des "alten" Objekts erfolgt
    }

    return *this;
}

4. + Operator als Nicht-Member implementieren (aber eventuell als friend)

matrix operator+(const matrix& lhs, const matrix& rhs)
     {
         matrix ret(lhs);  // hierfür ist z.B. der Copy-Konstruktor nötig
         ret += rhs;      
         return ret; 
     }

Puh, hoffe ich hab nichts vergessen

dank deiner Hilfe habe ich es jetzt hinbekommen. Wuesste allerdings doch gerne
noch, was genau mein Fehler war. Der entscheidende Punkt muesste doch sein,
dass ich vorher den +-Operator als Member-Funktion mit nur einem Argument geschrieben habe. Versteh aber nicht, warum das einen Unterschied machen sollte.

Verwirrte Grueße,
Fabian

Daher beachte bei möglichst allen Übergaben, daß du einen Parameter als "const T&" deklarierst, sofern du nicht wirklich eine Kopie oder eine Referenz benötigst.

Fabian

... der Heap des Altern Objekt gelöscht werden? das Alte objekt existiert doch weiter, und gilt nur als Source Objekt für das neue... ? Oder hab ic hwas übersehen?

das Alte objekt existiert doch weiter, und gilt nur als Source Objekt für das neue... ? Oder hab ic hwas übersehen?

Mit "das alte Objekt" ist nicht das Quellobjekt rhs gemeint, sondern das, was vor der Zuweisung in *this stand.