Komplexe Zahlen als Klasse

Hi an alle,

ich habe eine Frage die sich auf Klassen bezieht. Und zwar sollen wir die komplexen Zahlen als Klasse definieren und im main-Teil testen (sprich zwei beliebige komplexe Zahlen eingeben und die Operatoren + - * und / testen). Das klappt optimal. Nun zu meiner Frage:

In einer zweiten Aufgabe sollen wir die Datei nun in 3 Dateien teilen (Ein Header, eine Implementation und ein Programm in dem der main-Teil läuft). Mir geht es um meine Implementation:

#include "complex.h"

		Complex::Complex() {re=im=0;}

		Complex::Complex (double nre, double nim) {
                re=nre;
                im=nim;
    }

        Complex Complex::operator+(Complex z){

		Complex *v = new Complex (re+z.re,im+z.im);
		return *v;
	}

        Complex Complex::operator-(Complex z){

        Complex *v = new Complex (re-z.re,im-z.im);
        return *v;
    }

        Complex Complex::operator*(Complex z){

        Complex *v = new Complex (re*z.re-im*z.im,re*z.im+im*z.re);
        return *v;
    }

        Complex::Complex operator/(Complex z){

            Complex *v = new Complex (

                (re*z.re+im*z.im)/(z.re*z.re+z.im*z.im),

                (im*z.re-re*z.im)/(z.re*z.re+z.im*z.im));

        return *v;
    }

Wenn ich diese nun im Terminal zusammen mit dem main-Teil starte bekomme ich als Fehlermeldung:

complex.cpp:29: error: ‘Complex operator/(Complex)’ must take exactly two arguments

Es gibt also einen Fehler in der Division. Kann mir jemand erklären, wie es dazu kommt und wie ich das behebe? Denn wenn ich es wie gesagt alles in einer Datei laufen lasse, klappt der /-Operator ja auch.

Vielen Dank und viele Grüße!

SeppJ

Complex Complex::operator+(Complex z){
        Complex Complex::operator-(Complex z){
        Complex Complex::operator*(Complex z){
        Complex::Complex operator/(Complex z){

Schau noch einmal ganz scharf hin, warum die ersten drei Zeilen richtig sind und die letzte nicht.

Übrigens ist das eher ungewöhnlich, diese Operatoren als Klassenmethoden zu implementieren, da dies automatische Konvertierungen verhindert. Sprich: Falls du einen Konstruktor hast, der z.B. einen double in ein Complex konvertiert, dann wird der hier nicht automatisch benutzt, wenn du einen Complex mit einem double addierst.

cooky451

Abgesehen davon produziert der Code überall Speicherlecks. Die ganzen new sind fehl am Platz, in C++ wird ein Objekt einfach so erstellt:

Complex v(re+z.re,im+z.im);
return v;

oder gleich:

return Complex(re+z.re,im+z.im);

Wenn du new benutzt, musst du sicherstellen, dass du den angeforderten Speicher auch wieder mit delete freigibst.

mgaeckler

wdposchmann schrieb:

Complex::Complex operator/(Complex z){

Deine Doppelpunkte sind falsch. Deine Definition hat keine Memberfunktion defniniert, sondern eine normale globale Funktion, die einen Wert vom Typ Complex::Complex zurückliefert. Ein solcher operator braucht dann beide Operanden als Funktionsargument.

Complex Complex::operator/(Complex z){

So ist's korrekt. Da Du bei den anderen es richtig gemacht hast, nehme ich an, daß es nur ein Flüchtigkeitsfehler ist.

BTW.: Wer ist Deiner Meinung nach dafür verantwortlich die Objekte, die Du in Deinen Definitionen mit new erzeugst, wieder freizugeben?

mfg Martin

Hey, danke euch für die Antworten. Jetzt funktioniert es reibungslos (es war nur der bemerkte Tippfehler).

Hab mir wegen der new auch schon Gedanken gemacht wegen dem fehlenden delete. Da werd ich mich die Tage nochmal genauer drum kümmern, mir war es wichtig, dass es jetzt mal läuft.

Vielen Dank nochmal!

cooky451

wdposchmann schrieb:

mir war es wichtig, dass es jetzt mal läuft.

Du machst es dir echt so schwer wie möglich, oder?

Complex::Complex()
  : re(0), im(0) // Google "Initialisierungsliste"
{}
Complex::Complex(double nre, double nim)
  : re(nre), im(nim) // s.o.
{}

Complex Complex::operator + (Complex z)
{
  return Complex(re + z.re, im + z.im);
}
Complex Complex::operator - (Complex z)
{
  return Complex(re - z.re, im - z.im);
}
Complex Complex::operator * (Complex z)
{
  return Complex(re * z.re - im * z.im, re * z.im + im * z.re);
}
Complex Complex::operator / (Complex z)
{
  return Complex((re * z.re + im * z.im) / (z.re * z.re + z.im * z.im),
                 (im * z.re - re * z.im) / (z.re * z.re + z.im * z.im));
}

Bitteschön.