überladen von Operatoren

[pepe_C]

hallo an alle,

ich habe ein problem undzwar versuche ich schon seit stunden einen + operator in einen * operator umzuwandeln was ja wie ich glaube gehen müsste in einer klasseninstanz, nun habe ich aber kein lehrbuch zur verfügung in dem das sinnvoll beschrieben wird wie ich das am besten anstellen soll.

kann mir einer von euch da weiterhelfen und mir eine kommentierte syntax zukommen lassen, weil das beispiel in der visual studio hilfe ist auf englisch und den sinn verstehe ich auch net so richtig

mfg

pepe_C

[Guybrush Threepwood]

Z.B. so

#include <stdio.h>


class A

{

public:

	A()

	{

		i = 5;

	}

	operator+ (int j)

	{

		i*=j;

	}

	int i;

};


int main()

{

	A a;

	a+3;

	printf ("%i\n",a.i);

	return 0;

}

[/PHP]

[Klotzkopp]

Eigentlich sollte operator+ seinen linken Operanden nicht ändern

[Guybrush Threepwood]

nujo das sollte ja nur das Prinzip verdeutlichen :floet:

meinetwegen auch so:

#include <stdio.h>


class A

{

public:

	A()

	{

		i = 5;

	}

	operator+ (int j)

	{

		return i*j;

	}

	operator= (int j)

	{

		i = j;

	}

	int i;

};


int main()

{

	A a;

	a=a+3;

	printf ("%i\n",a.i);

	return 0;

}

[/PHP]

[pepe_C]

//=================================ausgangspunkt===============================

#include <iostream>


using namespace std;

//===========Klassendefinition===================

class ctest

{

	private:

		int a;

		int b;

		int ergebnis;

	public:

		ctest()

		{

			a=10;

			b=2;

		};

		void ausgabe();

		void rechne();

};

//=============================Funktionen==============================

void ctest::ausgabe()

 {

	 cout << ergebnis;

 };


void ctest::rechne()

{

	ergebnis = a+b;

};

//============================programmspass==============================

main ()

{

	ctest probe;

	probe.rechne();

	probe.ausgabe();

}


//==================und nun umbau vom operator + in den operator *=======


//=================================umbau der klasse===============================

#include <iostream>

#include <stdio.h>


using namespace std;

//===========Klassendefinition===================

class ctest

{

	private:

		int a;

		int b;

		int ergebnis;

	public:

		ctest() : a(10), b(2) { }


		friend ctest operator+ (const ctest &a, const ctest &;


		void ausgabe() { cout << ergebnis << endl; };

		void rechne();

};

//=============================Funktionen==============================

//void ctest::ausgabe()

// {

//	 cout << ergebnis;

// };


void ctest::rechne()

{

	ergebnis = a+b;

};


ctest operator+(const ctest &a, const ctest &

{

	ctest m;

	m.ergebnis = a.a * b.b;

	return m;

};

//============================programmspass==============================

int main ()

{

	ctest a(100), b(10), ergebnis;

	ergebnis = a+b;

	ergebnis.ausgabe();

	fflush(stdin);

	getchar();


}[/code]

wie ihr seht einmal die klasse nurmal und dann mein versuch, weiß aber nicht ob ich auif dem richtigen wege bin

mfg

[Klotzkopp]

Ist das, was unter "ausgangspunkt" steht, der Code, der dir vorgegeben wurde? Da ist gar kein benutzerdefinierter Operator drin, den du umwandeln könntest.

Wenn du willst, dass bei a+b multipliziert wird: Dazu müsstest du den operator* für int überladen, und das geht nicht - du kannst Operatoren für eingebaute Typen nicht überladen.

Ganz allgemein kann man aber sagen, dass Funktionsdefinitionen kein Semikolon am Ende benötigen, und dass fflush(stdin) undefiniertes Verhalten erzeugt.

[pepe_C]

Wenn du willst, dass bei a+b multipliziert wird: Dazu müsstest du den operator* für int überladen, und das geht nicht - du kannst Operatoren für eingebaute Typen nicht überladen.

heißt das ich kann dem operator + nicht sagen wenn + aufgerufen wird dann multipliziere die beiden variablen.

ich habe gedacht ich kann mit der überladung erreichen, dass wenn ich sage + du bist ab jetzt * das der dann auch multipliziert. habe ich das denn falsch verstanden????

unsere tollen herdt bücher geben den sinn der überladen von operatoren technik nicht preis.

also sitze ich hier und suche eine erklärung was ich damit tun kann!!!

mfg

[Klotzkopp]

heißt das ich kann dem operator + nicht sagen wenn + aufgerufen wird dann multipliziere die beiden variablen.

Es gibt nicht den operator+. Es gibt viele Überladungen davon. Du kannst für eigene Typen neue Operatorüberladungen anlegen. Aber du kannst nicht die bereits vorhandenen überschreiben.

ich habe gedacht ich kann mit der überladung erreichen, dass wenn ich sage + du bist ab jetzt * das der dann auch multipliziert. habe ich das denn falsch verstanden????

Du kannst Operatoren keine neue Identität zuweisen, insofern ist "du bist ab jetzt *" schlecht ausgedrückt. Du kannst für eigene Datentypen eine Überladung von operator+ erzeugen, die multipliziert - auch wenn sich mir der Sinn nicht erschließt.

unsere tollen herdt bücher geben den sinn der überladen von operatoren technik nicht preis.

also sitze ich hier und suche eine erklärung was ich damit tun kann!!!

Operatoren überlädt man dann für eigene Datentypen, wenn das die Verwendung erleichtert. Wenn du z.B. eine Klasse für Brüche hast, würde es sich anbieten, für diese Klasse die arithmetischen Operatoren zu überladen, damit du sie intuitiver verwenden kannst.

Ausnahme ist hier der operator=, den du immer dann überladen solltest, wenn eine Klasse mit dynamischem Speicher hantiert.

[Guybrush Threepwood]

und dass fflush(stdin) undefiniertes Verhalten erzeugt.

wobei man aber erwähnen muss das es unter Windows durchaus gemacht werden kann

/* You must flush the input buffer before using gets. */

fflush( stdin ); // fflush on input stream is an extension to the C standard

Quelle: http://msdn.microsoft.com/library/default.asp?url=/library/en-us/vclib/html/_crt_fflush.asp

[Klotzkopp]

wobei man aber erwähnen muss das es unter Windows durchaus gemacht werden kann

Das ist eine Frage des Compilers, nicht des Betriebssystems

Außerdem ist das hier das Standardforum. Compilerspezifische Erweiterungen gibt's nebenan

[pepe_C]

bei uns in der schule kam dann nach 7 stunden endlich mal ein lehrkörper der es uns "einfach" verklickert hat, seine aussage zu diesem thema:

man kann operatoren nicht überschreiben (wie ober gesagt) aber ich kann jedem (ein paar ausnahmen gibt es wohl) operator eine neu , wie sag ichs jetzt, möglichkeit definieren was er in genau dieser angegeben klasse für eine tätigkeit (sprich operation) übernehmen soll.

auf deutsch ich kann dem operator+ (was ja am ende auch nur eine funktion ist) sagen wenn er aufgerufen wird soll er hier nicht addieren sondern multiplizieren.

hoffe ich habe das jetzt verstanden.

wenn ich doch noch was falsch denke sagt es mir bitte

mfg

pepe_C

[Guybrush Threepwood]

Yupp, ist ja genau das was Klotzkopp gesagt hat