C++ Komplexe Zahlen Klasse

asc

scanbot90 schrieb:

Compiler Fehlermeldungen:
1>------ Erstellen gestartet: Projekt: Komplexe Zahlen Versuch 4, 1>f:\programmieren mit c++\komplexe zahlen versuch 4\komplexe zahlen versuch 4\komplexe zahlen.h(40) : error C2804: Binärer Operator '<<' hat zu viele Parameter
...
danke Syntax_error, das Tut. hab ich mir vor längerer Zeit angeschaut, aber es hat mir nicht wirklich weiter geholfen

Du hättest nochmal genau zu dem Punkt nachlesen sollen, wo der Fehler auftritt (Der erste Fehler ist entscheidend, die restlichen können immer Folgefehler sein).

Ich rezitiere mal:

Da der linke Operand das Streamobjekt ist und die Klassen der Standardbibliothek nicht nachträglich erweitert werden können, müssen die Streaming-Operatoren als freie Funktionen definiert werden.

Bei dir sind es aber Methoden, keine freien Funktionen. Genaueres wirst du im Tutorial unter 3.4 nachlesen können.

scanbot90

Sup schrieb:

f:\programmieren mit c++\komplexe zahlen versuch 4\komplexe zahlen versuch 4\komplexe zahlen.h(40) : error C2804: Binärer Operator '<<' hat zu viele Parameter

"operator<<" nimmt 2 parameter dein "operator<<" nimmt aber 3:
Einen ostream, ein complex UND den versteckten this-pointer, da es eine methode ist.

Einfach als freie Funktion implementieren (da sie nicht auf private member von Complex zugreift, muss sie auch nicht ein friend sein)

Jetzt wo ich es als Freie Funktion implementiert habe, sind noch mehr Fehlermeldungen aufgetreten!

class Complex
{
public:
	Complex(double r, double i)
	{
		m_real = r;
		m_imag = i;
	}
	~Complex (){};

	const std::string Complex::toStdString() const
	{
		std::ostringstream os;
		os << m_real << " + " << m_imag << "i";

		if (m_real == 0)
		{
			os << m_imag << "i";
		}

		if (m_imag == 0)
		{
			os << m_real;
		}

		if (m_imag < 0)
		{
			os << m_real << m_imag << "i";
		}

		return os.str();

	}

	/*std::ostream& operator << (std::ostream& os, const Complex &o)
	{
		return os << o.toStdString();
	}
	*/

	Complex operator + (const Complex &o)
	{	
		return Complex(o.m_real + m_real, o.m_imag + m_imag);
	}

	Complex operator - (const Complex &o)
	{
		return Complex(o.m_real - m_real, o.m_imag - m_imag);
	}

	Complex operator * (const Complex &o)
	{
		return Complex((o.m_real * m_real) - (o.m_imag * m_imag), (o.m_real * m_imag) + (o.m_imag * m_real));
	}

	Complex operator / (const Complex &o)
	{
		return Complex(((o.m_real * m_real) + (o.m_imag * m_imag)) /((m_real * m_real) + (m_imag * m_imag)),
			((o.m_imag * m_real) - (o.m_real * m_imag)) / (( m_real * m_real) + (m_imag * m_imag)));
	}

	/*
	Complex operator| (const Complex &o)
	{
		return Complex (sqrt((o.m_real * o.m_real) + (o.m_imag * o.m_imag)));
	}
	*/

private:
double m_real, m_imag;

//protected:

};
	std::ostream& operator << (std::ostream& os, const Complex &o)
	{
		return os << o.toStdString();
	}

1>------ Erstellen gestartet: Projekt: Komplexe Zahlen Versuch 4, Konfiguration: Debug Win32 ------
1>Kompilieren...
1>Main.cpp
1>f:\programmieren mit c++\komplexe zahlen versuch 4\komplexe zahlen versuch 4\komplexe zahlen.h(14) : error C2079: 'os' verwendet undefiniertes class 'std::basic_ostringstream<_Elem,_Traits,_Alloc>'
1>        with
1>        [
1>            _Elem=char,
1>            _Traits=std::char_traits<char>,
1>            _Alloc=std::allocator<char>
1>        ]
1>f:\programmieren mit c++\komplexe zahlen versuch 4\komplexe zahlen versuch 4\komplexe zahlen.h(15) : error C2297: '<<': Ungültig, da der rechte Operand vom Typ 'const double' ist
1>f:\programmieren mit c++\komplexe zahlen versuch 4\komplexe zahlen versuch 4\komplexe zahlen.h(15) : error C2297: '<<': Ungültig, da der rechte Operand vom Typ 'const char [4]' ist
1>f:\programmieren mit c++\komplexe zahlen versuch 4\komplexe zahlen versuch 4\komplexe zahlen.h(15) : error C2297: '<<': Ungültig, da der rechte Operand vom Typ 'const double' ist

Also wie gesagt ich bin Anfänger, also habt gedult mit mir (seit 2,5 Monaten setzte ich mich mit c++ auseinander)

asc

scanbot90 schrieb:

...

Bitte poste nur den ersten, maximal die ersten 3 Fehlermeldungen. Grundsätzlich sind viele Fehler auf immer den ersten zurückzuführen.

Syntax_error

class Complex
{
public:
    Complex(double r, double i)
    {
        m_real = r;
        m_imag = i;
    }
    ~Complex (){};

du hast hier nirgens m_imag und m_real deklariert und in Zeile 75 auf einmal:

private:
double m_real, m_imag;

Komplett verwirrt?

gruß
syntax

asc

Syntax_error schrieb:

...Komplett verwirrt?...

Könnte es sein das du es bist? Es sind Membervariablen die im Konstruktor verwendet werden, was ist daran auszusetzen? (Auch wenn ich die Initialisierungsliste statt der Zuweisung vorziehen würde).

asc

Fehlt vielleicht ein Include <sstream>?

scanbot90

asc schrieb:

Fehlt vielleicht ein Include <sstream>?

ja hat gefehlt! Mein Chef setzt sich auch gerade damit auseinander, versteht aber auch nicht warum es dann heißt

1>f:\programmieren mit c++\komplexe zahlen versuch 4\komplexe zahlen versuch 4\komplexe zahlen.h(42) : error C2804: Binärer Operator '<<' hat zu viele Parameter
1>f:\programmieren mit c++\komplexe zahlen versuch 4\komplexe zahlen versuch 4\komplexe zahlen.h(42) : error C2333: 'Complex::operator <<': Fehler in Funktionsdeklaration; Funktionstext wird übersprungen
1>f:\programmieren mit c++\komplexe zahlen versuch 4\komplexe zahlen versuch 4\main.cpp(14) : error C2679: Binärer Operator '<<': Es konnte kein Operator gefunden werden, der einen rechtsseitigen Operanden vom Typ 'Complex' akzeptiert (oder keine geeignete Konvertierung möglich)
1>

Aktuell sieht die Headerfile jetzt so aus:

#include <sstream>

class Complex
{
public:
	Complex(double r, double i)
	{
		m_real = r;
		m_imag = i;
	}
	~Complex (){};

	const std::string Complex::toStdString() const
	{
		std::ostringstream os;
		os << m_real << " + " << m_imag << "i";

		if (m_real == 0)
		{
			os << m_imag << "i";
		}

		if (m_imag == 0)
		{
			os << m_real;
		}

		if (m_imag < 0)
		{
			os << m_real << m_imag << "i";
		}
		return os.str();

	}

	std::ostream& operator << (std::ostream& os, const Complex &o)
	{
		return os << o.toStdString();
	}

	Complex operator + (const Complex &o)
	{	
		return Complex(o.m_real + m_real, o.m_imag + m_imag);
	}

	Complex operator - (const Complex &o)
	{
		return Complex(o.m_real - m_real, o.m_imag - m_imag);
	}

	Complex operator * (const Complex &o)
	{
		return Complex((o.m_real * m_real) - (o.m_imag * m_imag), (o.m_real * m_imag) + (o.m_imag * m_real));
	}

	Complex operator / (const Complex &o)
	{
		return Complex(((o.m_real * m_real) + (o.m_imag * m_imag)) /((m_real * m_real) + (m_imag * m_imag)),
			((o.m_imag * m_real) - (o.m_real * m_imag)) / (( m_real * m_real) + (m_imag * m_imag)));
	}

private:
double m_real, m_imag;

//protected:

};

daddy_felix

Dein operator<< ist immer noch ein Member und keine freie Funktion

Dein operator<< ist keine freie Funktion! Wurde eigentlich oft genug erwähnt dass das falsch ist. Ich hatte auch gehofft ich hätte erklärt, warum diese Fehlermeldung auftritt.

scanbot90

daddy_felix schrieb:

Dein operator<< ist immer noch ein Member und keine freie Funktion

:DD ahh danke euch allen!

habe es jetzt als freie Funktion geschrieben.. und jetzt funktioniert es!

Ich kann dieses Forum nur an alle weiter empfehlen!
Liebe Grüße

SeppJ

Was genau macht deiner Meinung nach eigentlich Zeile 11?

scanbot90

@SeppJ: mein Chef meinte ich sollte noch einen Destruktor reinschreiben.. also habe ich das gemacht.. Dient zur Freigebung benutzter Ressourcen

vario-500

wenn der destruktor leer ist, kannst du ihn auch gleich weg lassen, da der compiler dann einen für dich erzeugt.

scanbot90

danke wie schon gesagt, bin bei den Anfängen

asc

scanbot90 schrieb:

@SeppJ: mein Chef meinte ich sollte noch einen Destruktor reinschreiben..

Wenn du keinen eigenen Destruktor schreibst, wird automatisch ein Leerer erzeugt.

Sprich: Du machst nichts anderes, als du bekommen würdest, wenn du ihn unnötigerweise selbst leer implementierst.

scanbot90 schrieb:

Dient zur Freigebung benutzter Ressourcen

Schön aus dem Lehrbuch rezitiert, aber unsinnig, wenn du keine Aufräumarbeiten durchführst.