Ich wollte heute mal das = überladen, musste aber dann in meinem Buch lesen, dass das Überladen von = nur in Klassen definiert werden darf. Weiter schreibt mein Buch dazu nichts. Ich verstehe allerdings nicht so ganz was mit "darf nur in Klassen definiert werden" gemeint ist. Ich hab hier mal Code produziert der aber nicht so ganz tut was ich will:

#include<iostream>
#include"test.h"

int main()
{
	INT a, b, c;

	a = 5;

return 0;
}

#ifndef TEST_H
#define TEST_H

class INT
{
private:
	double val;

public:
	INT() : val(0)
	{

	}

	INT(double v) : val(v)
	{

	}

	INT& operator = (INT &v)
	{
		val = v.val;

		return *this;
	}

	INT& operator + (INT &v)
	{
		val = val * v.val;

		return *this;
	}

};

#endif TEST_H

Ich weiß das überladen von + zu * ist sinnlos; es soll ja auch nur eine Übungsaufgabe sein! Primär geht es mir darum zu verstehen, wie ich = im Sinne einer Linkszweisung überladen kann!

INT& operator = (const INT &v)
    {
        val = v.val;

        return *this;
    }

P.S.: Dein Additionsoperator sollte besser einen INT, keinen INT& zurückgeben, das vermeidet ein paar komische Effekte.
Deine beiden Konstruktoren könntest du durch einen Defaultwert zu einem zusammenfassen. Ist double als Konstruktorargumentstyp nicht ein bisschen komisch für einen Integerersatz?
Derzeit macht dein Zuweisungsoperator übrigens das gleiche wie der Defaultzuweisungsoperator (es wird bei Bedarf nämlich automatisch einer erstellt, wenn man keinen angibt).

INT& operator = ( const INT& rhs )
    {
        this->x = rhs.x;

        return *this;
    }

MfG

Edit: SeppJ war mal wieder zu schnell...

Einen solchen Operator musst du aber in diesem Fall auch nicht selbst deklarieren oder definieren. operator= gehört zu den sogenannten "special member functions", die ggf automatisch generiert werden.

Ein Tipp noch bei binären Operatoren wie +, -, , /: Vermeide die Veränderung von Operanden; denn das würde keiner erwarten, dass bei c=a+b plötzlich a verändert wird. operator+ liefert auch normalerweise keine Referenz, sondern ein neues Objekt. Du hast hier operator+ so definiert, wie man eigentlich operator= implementiert. Außerdem solltest du solche Operatoren lieber als freie Funktionen implementieren. Das hätte hier dann den Vorteil, dass 23+Int(42) auch funktionierte, statt nur Int(42)+23.

Schon mal Danke für die vielen hilfreichen Antworten!

@SeppJ: Warum muss man hier const verwenden und was bewirkt const hier?

Weil du sonst der Funktion keine temporären (oder allgemein konstante) Werte per Referenz übergeben kannst. Hier hast du einen solchen Wert vorliegen, denn bei

a = 5;

steht links ein INT, rechts ein int. Einen operator=(INT, int) hast du aber nirgends definiert. Aber es gibt ja noch den Konstruktor INT(double v) , so dass der int über die Konvertierung nach double in einen INT konvertiert werden kann. Das dabei entstehende Objekt ist aber ein temporay vom Typ INT und kann nicht verändert werden. Die ursprüngliche Funktionssignatur INT& operator = (INT &v) sagt aber gerade aus, dass auch das v sich verändert (bzw. verändern kann), das passt daher nicht zusammen.

Ich hab jetzt mal versucht für einen eigenen Datentypen Vektor den output-Stream zu überladen. Leider funktioniert das noch nicht so ganz. Der Compiler spuckt mir einige Fehler aus. Hier der Code:

Deklaration in der Klasse:

friend ostream &operator << (ostream &output, const Vector &v);

Implementierung:

ostream& Vector::operator << (ostream &output, const Vector &v)
{
	output << "(" << v.x << "," << v.y << ")" << std::endl;

	return output;
}

Fehlermeldungen:

Fehler	1	error C2143: Syntaxfehler: Es fehlt ';' vor '&'	

Fehler	2	error C2433: 'ostream': 'friend' bei der Deklaration von Daten nicht zulässig	

Fehler	3	error C4430: Fehlender Typspezifizierer - int wird angenommen. Hinweis: "default-int" wird von C++ nicht unterstützt.	

Fehler	4	error C2061: Syntaxfehler: Bezeichner 'ostream'	

Fehler	5	error C4430: Fehlender Typspezifizierer - int wird angenommen. Hinweis: "default-int" wird von C++ nicht unterstützt.	

Fehler	6	error C2805: Binärer Operator '<<' hat zu wenig Parameter	

Fehler	7	error C2143: Syntaxfehler: Es fehlt ';' vor '&'	

Fehler	8	error C4430: Fehlender Typspezifizierer - int wird angenommen. Hinweis: "default-int" wird von C++ nicht unterstützt.	

Fehler	9	error C2086: 'int ostream': Neudefinition	

Fehler	10	error C2065: 'output': nichtdeklarierter Bezeichner	

Fehler	11	error C2059: Syntaxfehler: 'const'	

Fehler	12	error C2143: Syntaxfehler: Es fehlt ';' vor '{'	

Fehler	13	error C2447: '{': Funktionsheader fehlt - Parameterliste im alten Stil?	

Fehler	14	error C2143: Syntaxfehler: Es fehlt ';' vor '&'	

Fehler	15	error C2433: 'ostream': 'friend' bei der Deklaration von Daten nicht zulässig	

Fehler	16	error C4430: Fehlender Typspezifizierer - int wird angenommen. Hinweis: "default-int" wird von C++ nicht unterstützt.	

Fehler	17	error C2061: Syntaxfehler: Bezeichner 'ostream'	

Fehler	18	error C4430: Fehlender Typspezifizierer - int wird angenommen. Hinweis: "default-int" wird von C++ nicht unterstützt.	

Fehler	19	error C2805: Binärer Operator '<<' hat zu wenig Parameter

Das ist keine Memberfunktion der Klasse. So dachte dein Compiler an den shift operator.

Benutzte IDE: Visual Studio 2010
Benutzter Compiler: Der, der in VS2010 eingebaut ist.

Ich hab in verteilten Dateien gearbeitet. Ich kopiere jetzt alles für mich relevant erschienene hier rein:

Header-Datei:

#ifndef TEST_H
#define TEST_H

class Vector
{
private:
	double x;
	double y;
	double skalar;

public:
	Vector();
	Vector(double _x, double _y);

	Vector &operator + (const Vector vec);
	Vector &operator - (const Vector vec);
	double &operator * (const Vector vec);
	friend ostream &operator << (ostream &output, const Vector &v);
};

#endif TEST_H

Implementierungsdatei:

#include<iostream>
#include"test.h"
//using namespace std;

Vector::Vector() : x(0), y(0)
{

}

Vector::Vector(double _x, double _y) : x(_x), y(_y)
{

}

Vector& Vector::operator + (const Vector vec)
{
	x = x + vec.x;
	y = y + vec.y;

	return *this;
}

Vector& Vector::operator - (const Vector vec)
{
	x = x - vec.x;
	y = y - vec.y;

	return *this;
}

double& Vector::operator * (const Vector vec)
{
	x = x * vec.y;
	y = y * vec.y;
	skalar = x + y;

	return skalar;
}

ostream& Vector::operator << (ostream &output, const Vector &v)
{
	output << "(" << v.x << "," << v.y << ")" << std::endl;

	return output;
}

Die main-Datei hat keine Auswirkung auf die Fehler! Egal ob ich Vektoren deklariere oder nicht, ob ich sie schon ausgeben lasse, oder nicht. Alles egal. Deshalb lass ich die main mal weg. Ich hoff, jetzt entspricht es dem Standard hier im Board.

Dazu brauchst du noch entweder den Header iosfwd , ostream oder gleich iostream .

klasse:

friend std::ostream &operator << (std::ostream &output, const Vector &v);

Implementierung:

std::ostream& Vector::operator << (std::ostream &output, const Vector &v)
{
	output << "(" << v.x << "," << v.y << ")" << std::endl;

	return output;
}

So siehts nach den veränderungenaus. alles andere ist so geblieben. Fehlermeldung:Fehler 1 error C2039: '<<': Ist kein Element von 'Vector'

Header-Datei:

#ifndef TEST_H
#define TEST_H

class Vector
{
private:
	double x;
	double y;
	double skalar;
public:
	Vector();
	Vector(double _x, double _y);

	Vector &operator + (const Vector vec);
	Vector &operator - (const Vector vec);
	double &operator * (const Vector vec);
	friend ostream &operator << (ostream &output, const Vector &v);
};

Du hast wieder ? mit ?= verwelchselt, diesmal im Falle +, - und * anstelle des Fragezeichens.

int a = 23;
int b = 42;
a+b; //verändert a nicht!!!

Im Wesentlichen hast du den letzten Absatz meines vorherigen Beitrags komplett ignoriert.

#ifndef TEST_H
#define TEST_H

class Vector
{
private:
	double x;
	double y;
	double skalar;

public:
	Vector();
	Vector(double _x, double _y);

	Vector &operator += (const Vector vec);
	Vector &operator + (const Vector vec);

	Vector &operator -= (const Vector vec);
	Vector &operator - (const Vector vec);

	double &operator * (const Vector vec);
	friend std::ostream &operator << (std::ostream &output, const Vector &v);
};

#endif TEST_H

#include<iostream>
#include"test.h"

Vector::Vector() : x(0), y(0)
{

}

Vector::Vector(double _x, double _y) : x(_x), y(_y)
{

}

Vector& Vector::operator += (const Vector vec)
{
	x = x + vec.x;
	y = y + vec.y;

	return *this;
}

Vector& Vector::operator + (const Vector vec)
{
	Vector tmp(x, y);

	return tmp += vec;
}

Vector& Vector::operator -= (const Vector vec)
{
	x = x - vec.x;
	y = y - vec.y;

	return *this;
}

Vector& Vector::operator - (const Vector vec)
{
	Vector tmp(x, y);

	return tmp -= vec;
}

double& Vector::operator * (const Vector vec)
{
	x = x * vec.y;
	y = y * vec.y;
	skalar = x + y;

	return skalar;
}

std::ostream& operator << (std::ostream &output, const Vector &v)
{
	output << "(" << v.x << "," << v.y << ")" << std::endl;

	return output;
}

Danke Nymer, dass du mich nochmal drauf aufmerksam gemacht hast! Jetzt funktioniert übrigens die gesamte Klasse! Danke an euch. Das hat mir sehr weiter geholfen! Über eine Rückmeldung von Krümelkacker würde ich mich sehr freun, ob das dem entspricht, was er mir beibringen wollte

return output << "(" << v.x << "," << v.y << ")" << std::endl;

schreiben anstatt:

output << "(" << v.x << "," << v.y << ")" << std::endl;

    return output;

, was den gleichen Effekt hat.
Ich persönlich finde das schöner .

@Krümelkacker: Hier mal nochmal die Variante die du mir vorgeschlagen hast. Ich hoffe, dass das dem entspricht, was du mir beibringen wolltest:

Du gibst bei operator+ und co Referenzen auf temporäre Objekte zurück, die dann ungültig werden. Bei operator+ und co fehlt noch ein const am Ende der Deklarationen. Die Parameter würde ich als Referenz-auf-konstant entgegen nehmen. Operator verändert das Objekt auf der linken Seite und gibt eine Referenz auf ein Datenelement der linken Seite zurück*. Das ist eine extrem schlechte Idee für einen binären Operator, der normalerweise seine Operanden nicht verändert und nur einen neuen Wert zurück gibt.

Nur mal so ein Beispiel:

Vector& Vector::operator + (const Vector vec)
{
	Vector tmp(x, y);
	return tmp += vec;
}

hätte lieber

Vector Vector::operator + (const Vector& vec) const // <- const nicht vergessen!
{ //  ^ keine Referenz!!               ^ Referenz!!
    Vector tmp(x, y);
    tmp += vec;
    return tmp; // <-- so aufgeschrieben erlaubt es noch die NRVO-Optimierung
}

heißen sollen. Allerdings kannst du es auch so schreiben:

Vector Vector::operator + (const Vector& vec) const
{
    return Vector(x+vec.x,y+vec.y);
}

wobei ich natürlich nicht weiß, was das mit deinem skalar -Member da soll. Der wird ja nicht mal irgendwo initialisiert!

Prinzipiell würde ich operator+, operator-, operator* aus "Symmetriegründen" auch als freie Funktionen definieren. Was das genau heißt, hatte ich letztens schon angedeutet.

Du musst übrigens nicht das Rad neu erfinden. Es gibt beispielsweise eine nette Matrix/Vektor-Bibliothek mit diversen netten Funktionen: Eigen.

Prinzipiell würde ich operator+, operator-, operator* aus "Symmetriegründen" auch als freie Funktionen definieren. Was das genau heißt, hatte ich letztens schon angedeutet.

Das würde ich unbedingt machen und so macht man es afaik auch.
Wenn du z.B. noch multiplizieren mit einem Skalar hinzufügst, geht das so nicht (V*s) geht (s*V) nicht.

Du musst übrigens nicht das Rad neu erfinden. Es gibt beispielsweise eine nette Matrix/Vektor-Bibliothek mit diversen netten Funktionen: Eigen.

Eigen ist toll. Einfach inkludieren und fertig.
Vielleicht will er aber auch einfach operatoren Überladung üben.

Ja, ich will in der Tat die Operatorüberladung üben. Ich werde mir so gut es geht mir eure Tips zu herzen nehmen! Ich hab hier nun übrigens wieder ein Problemchen mit einer Klasse und einer Überladung. Verwendete IDE und Compiler: VS2010.

Header:

class Bitvector
{
private:
	unsigned int bits;	//Anzahl der Bits im Bitvektor
	unsigned char byte;	//chars aus denen sich der Bitvektor zusammensetzt
	unsigned char* bv;	//pointer auf die aneinandergereihten chars

public:
	Bitvector();
	Bitvector(unsigned int bits);
	~Bitvector();

	friend std::ostream& operator << (std::ostream& output, Bitvector &bv);
};

Implementierung:

std::ostream& operator << (std::ostream &output, const Bitvector &bv)
{
	bv.bits; //hier gibts den Fehler!

return output;
}

Compilerfehler:

Fehler	1	error C2248: "Bitvector::bits": Kein Zugriff auf private Member, dessen Deklaration in der Bitvector-Klasse erfolgte.

Ich brauch in der Überladung Zugriff auf die "bits" der Klasse. Wie mach ich das dann hier? Ich hab eigentlich gedacht, dass ich hier ohne Probleme mein Wissen von gester anwenden kann, aber schon kommt wieder was das mich raushaut... Könnt ihr mir helfen?

Edit:
Wenn ich den Zugriffsspezifizierer private auf public ändere, bekomme ich hier Zugriff auf bits. Warum kann ich bei dieser Ausgabeoperator-Überladung nicht, wie in "normalen" Methoden üblich, auf private-Variablen zugreifen? Wie gehe ich dann hier vor? Muss ich eine Methode schreiben, die mir den Wert private-Var. liefert? Oder gibt es eine andere Möglichkeit?

Übrigens wie mein Compiler richtig meckert, musst du so unbedingt den Copy-Konstruktor und den operator= überladen. Am besten gar keine Pointer verwernden.

Edit: "friend" darf außerhalb einer Klasse nicht verwendet werden, sagt mein Compiler. Wo ist dann der Fehler?

Das friend den Zugriff auf private Vars/Methoden regelt weiß ich natürlich, deswegen hab ich es ja in der h-Datei auch hingeschrieben

[cpp]class Bitvector
{
...
friend std::ostream& operator << (std::ostream& output, Bitvector &bv);
}; [/cpp]

std::ostream& operator << (std::ostream &output, const Bitvector &bv)
{
    bv.bits; //hier gibts den Fehler!

return output;
}

Das meinte ich. (Steht da doch auch(Hmm.. vielleicht auch etwas mehrdeutig))

Nun hab ich die Überladung um das hier erweitert:

std::ostream& operator << (std::ostream &output, const Bitvector &bv)
{
	for(unsigned int i=0; i<=bv.bits; i++)
	{
		if(i == 0)
		{
			output << bv.getBit(i);  //Fehler
		}
		else if((i%4) == 0)
		{
			output << " " << bv.getBit(i);  //Fehler
		}
		else if(i > 0)
		{
			output << bv.getBit(i);  //Fehler
		}
	}

return output;
}

Probleme macht nun die getBit()-Methode. Der Compiler sagt: "Fehler 1 error C2662: 'Bitvector::getBit': this-Zeiger kann nicht von 'const Bitvector' in 'Bitvector &' konvertiert werden"

Die getBit()-Methode gibt einen einzelnen char zurück. Wie greife ich korrekt auf Methoden aus Überladungen zu? Es liegt am const, nicht wahr? Muss ich nun die getBit() als const deklarieren?

Die getBit()-Methode gibt einen einzelnen char zurück. Wie greife ich korrekt auf Methoden aus Überladungen zu? Es liegt am const, nicht wahr? Muss ich nun die getBit() als const deklarieren?

Ja.

Sag mal: Wie lernst du eigentlich C++? Es sieht nämlich nicht so aus, als hättest du ein schlaues C++ Buch vor dir liegen. Man würde dann erwarten, dass du dann schon viel weiter wärst.