ich will mal die Operator-Ueberladung ausprobieren.

Dazu habe ich eine Klass MyObj, die erstmal ncihts spezielles kann, außer mit id() die id auszugeben :>

Jetzt will ich einen Funktionskopf erweitern, wo der << operator so überladen werden soll, dass die id ausgegeben wird.

std::ostream& operator<<(std::ostream& os, const MyObj& o) {

	return os;
}

das hab ich jetzt erstmal so gemacht:

std::ostream& operator<<(std::ostream& os, const MyObj& o) {

	return std::cout<<o.id();
}

in der main kann ich das ganze jetzt so aufrufen:

MyObj o;
std::cout<<"o: "<<o<<endl;

funktioniert auch alles wunderbar, ich frag mich nur ob das im sinne der Aufgabe ist. Ich geb ja jetzt nicht wirklich das ostream objekt os zurück oder?

Außerdem finde ich das sowieso relativ verwirrend mit der Operatorüberladung.
Ich könnte es ja z.b. auch so machen:

void MyObj::operator<<(  MyObj& mo){

		cout<<mo.getid()<<endl;
	}

und iner main

a<<(a);

ist das beides operatorüberladung?

gruß

std::ostream& operator<<(std::ostream& os, const MyObj& o) {

    os << o.id();
    return os;
}

Wenn du ein stream Objekt übergibst, warum nutzt du das dann nicht?

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

hehe, danke!
genau das wollte ich wissen. ich wusste nurnicht, wie ich das streamobjekt nutze

was ist mit meienr alternative?
Gruß

ist das beides operatorüberladung?

Ja, sobald du eine Funktion wie operator<< definierst ist das Operatorüberladung.
Dass deine Funktionen nicht besonders sinnvoll sind, steht auf einem anderen Blatt.

ja keine Frage. aber mir geht es nur darum wenn operatorüberladung gewünscht ist operatorüberladung zu zeigen. ich würd sowas wie operatprüberladung nei wirklich anwenden. wenn ich zwei objekte adieren will überade ich net den + operator sondern man ne methode .add ^^

Warum? Operatorüberladung ist eine ganz tolle Sache. Lass dich nicht von der komplizierten Begrifflichkeit abschrecken. Überladene Operatoren sind Funktionen wie jede andere auch. Du würdest quasi nur das Wort add durch operator+ ersetzen und schon hast du einen überladenen Operator.

ich würd sowas wie operatprüberladung nei wirklich anwenden. wenn ich zwei objekte adieren will überade ich net den + operator sondern man ne methode .add ^^

MyInt a, b, c, d;

d = (a+b)*c + (a+c)*b + a*b + b*c;
// vs
d = a.add(b).mul(c).add(a.add(c).mul(b)).add(a.mul(b)).add(b.mul(c));

ich würd sowas wie operatprüberladung nei wirklich anwenden. wenn ich zwei objekte adieren will überade ich net den + operator sondern man ne methode .add ^^

Damit sträubst du dich gegen C++.

int                  i = (a+b) * c;
float                i = (a+b) * c;
std::complex<double> i = (a+b) * c;
MyInt                i = (a.add(b)).mul(c);

Und die Inkonsistenz ist durchaus nicht nur Geschmackssache.

std::vector<T> vec;
...
std::accumulate(vec.begin(), vec.end(), 0);
// geht für T == int, float, std::complex, aber nicht für deinen MyInt.

Vom Hindernis für Generizität abgesehen hat dein Ansatz weitere Probleme.

MyInt GetDouble(MyInt value);
int GetDouble(int value);

MyInt a = 7;
int b = 5;

GetDouble(a).add(b); // ok
GetDouble(a).add(a); // ok
GetDouble(b).add(a); // nicht ok!
GetDouble(b).add(a); // nicht ok!

Daher wenn schon freie Funktionen anbieten, um Konvertierungen des linken Operanden zu erlauben. Bei Verwendung von Operatorüberladung ist das ein Muss, wiel sonst (mit Memberfunktionen) schon dieser Code Probleme verursacht:

a + b; // ok
a + a; // ok
b + b; // ok
b + a; // nicht ok!