Ich versuche mich gerade beim Überladen von Operatoren.
Dazu habe ich mir eine Klasse Complex gebaut, um real- und immaginäre Anteile zu addieren.

#include <cstdlib>
#include <iostream>
#include <string>

class Complex{

	private:

		double real;
		double imaginary;

	public:

		friend std::ostream& operator<<(std::ostream&, Complex&);
		Complex(double rreal, double iimaginary);
		Complex& operator+(const Complex&,const Complex&);
		Complex& operator=(const Complex&);
		Complex& operator-(const Complex&);
};

int main(int argc, char *argv[])
{

	Complex my_Complex_1(10.0, 11.1);
	Complex my_Complex_2(23.23, 3.232);

	std::cout<<my_Complex_2<<std::endl;

   system("PAUSE");
   return EXIT_SUCCESS;
}

Complex::Complex(double rreal, double iimaginary)
	: real(rreal), imaginary(iimaginary){}

std::ostream& operator<<(std::ostream&, Complex& a){

	std::cout<<a.real<<std::endl<<a.imaginary<<std::endl;

}

Complex& operator+(const Complex& a, const Complex& b){

	Complex my_Complex_3(0,0);

	my_Complex_3.real=a.real+b.real;
	my_Complex_3.imaginary=a.imaginary+b.imaginary;

	return my_Complex_3;
}

Der << operator funktioniert soweit, aber die Addition lässt er nicht kompilieren.
Fehler:

main.cpp:17: error: `Complex& Complex::operator+(const Complex&, const Complex&)' must take either zero or one argument

main.cpp: In function `Complex& operator+(const Complex&, const Complex&)':
main.cpp:10: error: `double Complex::real' is private
main.cpp:52: error: within this context
main.cpp:10: error: `double Complex::real' is private
main.cpp:52: error: within this context
main.cpp:10: error: `double Complex::real' is private
main.cpp:52: error: within this context

Ich verstehe ja die Fehlermeldungen, aber im C++ Primer ist auch ein 2ter Operand vorhanden:

Sales_item operator+(const Sales_item&, const Sales_item&);

Kann mir wer erklären warum das bei mir nicht geht?

Danke im Vorraus

Im Primer steht aber noch ein friend davor, oder?

Ja aber nur vor ostream und istream.
sonst nirgends.

Complex& operator + (Complex* this, const Complex&, const Complex&);

Was natürlich keinen Sinn macht. Du musst dich zwischen Membern und freien Funktionen entscheiden, wobei ich freien Funktionen hier den Vorzug geben würde. Und operator + gibt kein Complex& sondern ein Complex zurück. (Und dass es std::complex gibt ist dir hoffentlich klar. ;))

Complex& operator + (Complex* this, const Complex&, const Complex&);

Was natürlich keinen Sinn macht. Du musst dich zwischen Membern und freien Funktionen entscheiden, wobei ich freien Funktionen hier den Vorzug geben würde. Und operator + gibt kein Complex& sondern ein Complex zurück. (Und dass es std::complex gibt ist dir hoffentlich klar. ;))

Das mit *this wusste ich nicht, darum ist die Funktion im C++Primer außerhalb der Klasse.

Das mit std::Complex wusste ich nicht, danke für die Info.

Vielen Dank cooky451! Sehr hilfreich

Meine Member sind ja private. Wie kann ich auf diese zugreifen in der operator+()Funktion?

Trotzdem noch eine Frage:

Meine Member sind ja private. Wie kann ich auf diese zugreifen in der operator+()Funktion?

Vielleicht schaust du im Buch noch mal nach der Erklärung zu friend.

Meine Member sind ja private. Wie kann ich auf diese zugreifen in der operator+()Funktion?

So wie du auch sonst zugreifen würdest: Über irgendwelche public Member. Mach dir halt getter. Siehe auch http://en.cppreference.com/w/cpp/numeric/complex daran kannst du dich orientieren.

Edit: Und das mit friend für operator + ist keine gute Idee. Irgendwie willst du ja eh auf die einzelnen Teile zugreifen können.

OK danke erstmal cooky451.

Ich habs jetzt so gemacht (Bitte sofort kritisieren, wenn der Code eurer Meinung nach unschön ist)

#include <cstdlib>
#include <iostream>

class Complex{

	private:

		double real;
		double imaginary;

	public:

		friend std::ostream& operator<<(std::ostream&, Complex&);
		Complex(double rreal, double iimaginary);
		double get_real() const;
		double get_imag() const;
};
		Complex operator+(const Complex&, const Complex&);
		Complex operator-(const Complex&, const Complex&);

int main(int argc, char *argv[])
{

	Complex my_Complex_1(10.0, 11.1);
	Complex my_Complex_2(23.23, 3.232);
	Complex my_Complex_3=my_Complex_1+my_Complex_2;
	Complex my_Complex_4=my_Complex_1-my_Complex_2;

	std::cout<<my_Complex_2<<std::endl;
	std::cout<<my_Complex_1<<std::endl;
	std::cout<<std::endl<<my_Complex_3<<std::endl;
	std::cout<<std::endl<<my_Complex_4<<std::endl;

   system("PAUSE");
   return EXIT_SUCCESS;
}

Complex::Complex(double rreal, double iimaginary)
	: real(rreal), imaginary(iimaginary){}

std::ostream& operator<<(std::ostream&, Complex& a){

	std::cout<<a.real<<std::endl<<a.imaginary<<std::endl;

}

Complex operator-(const Complex& a, const Complex& b){

	double lokal_imag_1=a.get_imag();
	double lokal_real_1=a.get_real();
	double lokal_imag_2=b.get_imag();
	double lokal_real_2=b.get_real();

	Complex Complex_sum(lokal_real_1-lokal_real_2, lokal_imag_1-lokal_imag_2);
}

Complex operator+(const Complex& a, const Complex& b){

	double lokal_imag_1=a.get_imag();
	double lokal_real_1=a.get_real();
	double lokal_imag_2=b.get_imag();
	double lokal_real_2=b.get_real();

	Complex Complex_sum((lokal_real_1+lokal_real_2),(lokal_imag_1+lokal_imag_2));
	return Complex_sum;
}

double Complex::get_imag() const{

	return imaginary;
}

double Complex::get_real() const{

	return real;
}

Die Addition funktioniert. aber... bei der Subtraktion bekomme ich so was raus:
1.#QNAHN
3.343456e+235
Das stimmt natürlich nicht.
1.Warum kommt da so ein Mist heraus?

2. Warum kann ich nicht einfach schreiben:
[cpp]
std::cout<<my_Complex_1+my_Complex_2<<std::endl;

da kommen ganz kryptische Fehlermeldungen.. a la:

33 C:\Dev-Cpp\main.cpp no match for 'operator<<' in '(&std::cout)->std::basic_ostream<_CharT, _Traits>::operator<< [with _CharT = char, _Traits = std::char_traits<char>](std::endl [with _CharT = char, _Traits = std::char_traits<char>]) << operator+(((const Complex&)((const Complex*)(&my_Complex_3))), ((const Complex&)((const Complex*)(&my_Complex_1))))'

Das const fehlt da. Sollte std::ostream& operator << (std::ostream&, const Complex&) heißen.

Das Problem mit der Subtraktion hat sich erledigt.
Hatte ein return vergessen bei der Funktion.

ostream& operator <<(ostream& os, const Complex& complex)
{
  return os << '(' << complex.get_real() << '+i' << complex.get_imag() << ')';
}

Edit: ups, jetzt erst sehe ich daß du den Operator ja implementiert hast (bzw. versuchst hast, da so wie cooky451 schreibt, das const fehlt ;-).
Jedoch solltest du dort niemals direkt nach cout schreiben, sondern immer in den übergebenen Stream - falls du mal dies in eine Datei ausgeben willst, würdest du dich wundern!!!

Complex& operator+( const Complex& a )
{
    Complex my_Complex_3( 0,0 );

    my_Complex_3.real = a.real+ this->a;
    my_Complex_3.imaginary = a.imaginary + this->b;

    return my_Complex_3;
}

Würde das nicht auch gehen?

MfG

Das Problem von operator+ als Memberfunktion besteht darin, dass die Argumente asymmetrisch behandelt werden. Der linke Operand muss vom Typ Complex sein, während der rechte auch durch implizite Konvertierung zustande kommen kann.

Gerade komplexe Zahlen sind ein gutes Beispiel hierfür, da sich ein Konstruktor

Complex(double real = 0, double imag = 0);

anbietet, welcher eine implizite Konvertierung von double -Werten ermöglicht. Wäre operator+ ein Member, ergäbe sich folgende Problematik:

Complex c(1, 2);
double d = 3;

c + d // Funktioniert
d + c // Fehler: Linker Operand muss Klassentyp haben

Ich weiß nicht!

Aber ich habs gestern noch ein bisschen verfeinert, was den Stil angeht und habs so gemacht:

Complex operator+(const Complex& a, const Complex& b){

	Complex Complex_temp(a.get_real()+b.get_real(), a.get_imag()+b.get_imag());

	return Complex_temp;
}

Complex operator-(const Complex& a, const Complex& b){

	Complex Complex_temp(a.get_real()-b.get_real(), a.get_imag()-b.get_imag());

	return Complex_temp;

Wobei ich deine Lösung auch interessant finde. Werd ich gleich mal ausprobieren.

Danke.

MfG

Wobei ich deine Lösung auch interessant finde. Werd ich gleich mal ausprobieren.

Und dann liest du noch mal schnell den Beitrag von Nexus.
Und deine temp-Variablen sind auch, na ja, zumindest Ansichtssache. Zugegeben, für das Kompilat wird das keinen Unterschied machen, aber Übersichtlicher wird das dadurch jetzt nicht gerade, oder? :p

Complex operator-(const Complex& a, const Complex& b){

    Complex Complex_temp(a.get_real()-b.get_real(), a.get_imag()-b.get_imag());

    return Complex_temp; 
}

oder das

Complex operator-(const Complex& a, const Complex& b){

    double lokal_imag_1=a.get_imag();
    double lokal_real_1=a.get_real();
    double lokal_imag_2=b.get_imag();
    double lokal_real_2=b.get_real();

    Complex Complex_sum(lokal_real_1-lokal_real_2, lokal_imag_1-lokal_imag_2);

    return Complex_sum;
}

Da die Summenbildung Complex_sum(...) ist in beiden Fällen ca. gleich lang. Aber es fallen die lokalen Variablen weg.

Complex operator - (const Complex& lhs, const Complex& rhs)
{
  return Complex(lhs.real() - rhs.real(), lhs.imag() - rhs.imag());
}

Complex operator - (const Complex& lhs, const Complex& rhs)
{
  double real = lhs.real() - rhs.real();
  double imag = lhs.imag() - rhs.imag();
  return Complex(real, imag);
}

Aber da kommen wir doch langsam in einen Stilbereich der kaum noch sachlich diskutiert werden kann, insofern mach halt was dir Spaß macht.

ostream& operator <<( std::ostream& os, const Vec& data )
{
	return os << data.x1;
}

Warum muss std::ostream& os als Parameter mit dazu? Ich würde mich über eine Erklärung sehr freuen.

MfG yihaaa

Warum muss std::ostream& os als Parameter mit dazu? Ich würde mich über eine Erklärung sehr freuen.

Weil da reingeschrieben wird?