ich habe ein Klasse, die ein schwarz-weiß Bild darstellt. Nun möchte ich den ! - Operator überladen, damit ich schön alle schwarzen Pixel gegen weiße und alle weißen gegen schwarze austauschen kann. Ich drehe das Bild also quasi um.

Mein Code lautet:

Bild* operator!(void);
//..,
Bild* Bild::operator!() {
  return this;
}
//...
BildMama* foo() { //BildMama beerbt Bild
  Bild* p = new Bild();
  return !p //Fehler
}

Die Fehlermeldung lautet: error: cannot convert ‘bool’ to ‘Shape*’ in return

Zwar ist diese eindeutig, aber ich verstehe ihn trotzdem nicht. Woher kommt plötzlich bool? Wie kann ich den Fehler beheben?

Kann mir jemand helfen?
Vielen Dank
LG, freakC++

Bild operator!(void);
//..,
Bild Bild::operator!() {
  return this;
}
//...
BildMama* foo() { //BildMama beerbt Bild
  Bild* p = new Bild();
  p = !p;
  return &p //Fehler
}

Jetzt kommt jedoch der Fehler "could not convert ‘this’ from ‘Bild* const’ to ‘Bild’. Woran kann das liegen?

Vielen Dank

Der Fehler kommt übrigens in der Zeile "return this".

edit: Ich muss mich korrigieren. Das war wohl doch nicht der Fehler.

Bild* Bild::operator&(Bild* b) {
//...
	return this;
}

//Der Aufruf:

Bild* shape1 = new Bild();
Bild* shape2 = new Bild();//Rechteck erstellen
shape1 = shape1 & shape2; //Fehler

Die Fehlermeldung lautet:

error: invalid operands of types ‘Bild*’ and ‘Bild*’ to binary ‘operator&’

Das kann ich jedoch nicht nachvollziehen. Wie muss ich den Code anpassen, damit obiges Statement korrekt wird?

Danke nochmal!
LG, freakC++

anscheinend kommst du immer noch nicht mit Pointern und Objekten zu Recht [sic]

Ergänzend dazu: Modern C++

Ich verstehe jedoch deinen Punkt nicht. Hier noch einmal der Code:

Bild* operator&(Bild* p) {
 return this;
}

Bild* b1 = new Bild();
Bild* b2 = new Bild();

b1 = b1 & b2;

Der Operator & bekommt einen Zeiger auf ein Bild Objekt. b2 ist aber doch ein Zeiger. Daher sollte das nicht das Problem sein.

error: invalid operands of types ‘Bild*’ and ‘Bild*’ to binary ‘operator&’

Könnt ihr mir denn helfen bei der Fehlerbehebung?
Danke!

Könnt ihr mir denn helfen bei der Fehlerbehebung?

Ganz einfach, verzichte auf die Pointer.

Bild b1;
Bild b2;

b1 = b1 & b2; // et voilà

Das Problem ist, dass du hier zwei Bild * mit dem Operator & verknüpfst. Der &-Operator ist aber für Bild * (und sonstige Pointer) nicht definiert. Du willst nicht die Pointer verunden, sondern die Bilder.

Bild* b1 = new Bild();
Bild* b2 = new Bild();

b1 = (*b1) & (*b2);

b1 ist ein Pointer, (*b1) ist ein Bild, verunden von Pointern geht nicht, verunden von Bildern geht.

Bild* operator&(Bild* p) {
 return this;
}

Das sieht so aus, als wolltest du das Verunden zwischen Bild-Pointern definieren. Das geht nicht. Pointer sind eingebaut, eingebauten Datentypen kann man ihre Operatoren nicht überladen. Du musst schon den &-Operator für Bilder definieren, nicht für Bildpointer.

Bild operator&(const Bild &b){
    Bild neuesBild = generiereIrgendwieNeuesBildAusThisUndb(this, &b);
    return neuesBild;
}

Bild operator&(const Bild &b){
    Bild neuesBild = generiereIrgendwieNeuesBildAusThisUndb(this, &b);
    return neuesBild;
}

Ich habe deine Idee mal versucht durchzuführen, aber leider haben sich meine Befürchtungen bewahrheitet. Bei dir ist nun das Problem, dass Du "neuesBild" zurückgibst, obwohl dieses eine lokale Variabel ist. Damit wird diese nach dem Ausführen der Funktion gelöscht und alles führt zu einem Segmentation Fault. Nun bringt es auch nichts "neuesBild" als Klassenvariabel einzuführen, weil die Operationen in verschiedenen Klassen durchgeführt werden. Kann man so überhaupt ganze Objekte zurückgeben?

Deswegen habe ich eben Zeiger benötigt.

Gibt es doch eine Lösung, wie ich dieses letzte Problem beheben kann oder muss ich doch auf Zeiger umsteigen?

Vielen Dank
LG, freakC++-

Bei dir ist nun das Problem, dass Du "neuesBild" zurückgibst, obwohl dieses eine lokale Variabel ist.

Das ist kein Problem, sondern völlig in Ordnung. Das Problem dürfte eher sein, dass die Bild-Klasse keinen ordentlichen Copy-Konstruktor hat.

Ich verstehe jedoch deinen Punkt nicht. Hier noch einmal der Code:

Bild* operator&(Bild* p) {
 return this;
}

Bild* b1 = new Bild();
Bild* b2 = new Bild();

b1 = b1 & b2;

Der Operator & bekommt einen Zeiger auf ein Bild Objekt. b2 ist aber doch ein Zeiger. Daher sollte das nicht das Problem sein.

error: invalid operands of types ‘Bild*’ and ‘Bild*’ to binary ‘operator&’

Hallo,
ich versuche dir mal zu erklären, warum das nicht geht:
1. Du hast eine Klasse definiert. D.h. du hast einen neuen Datentypen definiert.
2. Du hast innerhalb der Klasse den Operator & überladen.
3. Dein Datentyp heist Bild. D.h. du hast den Operator & für den Datentypen Bild überladen.
4. Du schaust dir den Datentyp von b1 und b2 an. Du siehst, dass diese beiden Variablen vom Typ Bild* sind. Wir erinnern uns, dass du den Operator & für den Typ Bild überladen hast. Und warum es nicht geht, dürfte dir jetzt ja klar sein: Datentyp Bild* != Datentyp Bild

vielen Dank für die zahlreichen Antworten. Ich habe nun Erfolg gehabt, indem zum einen einen korrekten Copy-Konstruktor definiert habe (der hatte tatsächlich noch gefehlt) und zum anderen ein "Bild" zurückgebe.

Dennoch verstehe ich nicht, warum diese Lösung nicht langsamer sein soll. Ich muss nun immer ein temporäres "Bild" anlegen, das dan zurückgeben wird. Wir bei mir nun nicht ziemlich viel hin und her kopiert. Dieses Problem müsste man mit Zeigern doch eigentlich umgehen, oder?

Vielen Dank
LG, freakC++

Ich habe nun Erfolg gehabt, indem zum einen einen korrekten Copy-Konstruktor definiert habe (der hatte tatsächlich noch gefehlt) und zum anderen ein "Bild" zurückgebe.

Hast meinen Link angeschaut? Modern C++. Sofern Bild richtig designt ist (keine internen Zeiger), dürfte es nicht nötig sein, einen Kopierkonstruktor zu schreiben. Poste am besten einmal deine Klasse Bild oder zumindest ihre Membervariablen.

freakC++ schrieb:

Ich muss nun immer ein temporäres "Bild" anlegen, das dan zurückgeben wird. Wir bei mir nun nicht ziemlich viel hin und her kopiert. Dieses Problem müsste man mit Zeigern doch eigentlich umgehen, oder?

Das Problem wird schon umgangen, aber nicht mit Zeigern.
Zum einen wäre da die Copy Elision, die ich schon genannt habe, du aber scheinbar überlesen hast. Schau mal da: Want Speed? Pass by Value.
Zum anderen gibt es mit C++11 nun RValue-References.