Du bist nicht angemeldet.

Stilllegung des Forums
Das Forum wurde am 05.06.2023 nach über 20 Jahren stillgelegt (weitere Informationen und ein kleiner Rückblick).
Registrierungen, Anmeldungen und Postings sind nicht mehr möglich. Öffentliche Inhalte sind weiterhin zugänglich.
Das Team von spieleprogrammierer.de bedankt sich bei der Community für die vielen schönen Jahre.
Wenn du eine deutschsprachige Spieleentwickler-Community suchst, schau doch mal im Discord und auf ZFX vorbei!

Werbeanzeige

1

05.03.2015, 10:48

[c++] operator== überladen

Guten Tag,

ich stehe gerade ein wenig auf dem Schlauch, wie ich das prinzipiell angehen soll.
Vorweg, ich weiß wie ich Operatoren syntaktisch richtig überlade, das ist nicht das Problem ;)

Ich fange direkt mal mit einem Beispiel an:

C-/C++-Quelltext

1
2
3
4
5
6
7
8
9
class Foo
{
   // member
};

class Bar : public Foo
{
   // weitere member
}


Jetzt ist hier die Frage, wie überlade ich hier den == Operator am sinnvollsten, wenn ich die einzelnen Member der beiden Objekte jeweils auf Gleichheit prüfen möchte?

Ich dachte hierbei an folgendes:

C-/C++-Quelltext

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
class Foo
{
    int x = 0;
    // weitere member

public:
    virtual bool compare(const Foo& other) const
    {
        return x == other.x;
    }
};

class Bar : public Foo
{
    int y = 0;
    // weitere member

public:
    bool compare(const Foo& other) const override
    {
        auto pOther = dynamic_cast<decltype(this)>(&other);
        return Foo::compare(other) && pOther && y == pOther->y;
    }
}

bool operator==(const Foo& lhs, const Foo& rhs)
{
    return lhs.compare(rhs);
}


Jedoch müsste ich bei dieser Methode "other" per dynamic_cast casten, was es ja prinzipiell erstmal zu vermeiden gilt. Gibt es hier also eine bessere Methode oder muss ich das in diesem Fall in Kauf nehmen?

mfg

2

05.03.2015, 12:27

Willst du denn wirklich Mandarinen mit Clementinen vergleichen?

Oder geht es dir darum Mandarinen mit Mandarinen und Clementinen mit Clementinen zu vergleichen?
Wer aufhört besser werden zu wollen hört auf gut zu sein!

aktuelles Projekt:Rickety Racquet

3

05.03.2015, 13:22

Genau das möchte ich ja erreichen. Da von foo öfter geerbt wird, will ich verhindern, dass 2 unterschiedliche Klassen miteinander verglichen werden. es sollen die fertigen Objekte und nicht irgendwelche unfertigen Oberklassen verglichen werden.

BlueCobold

Community-Fossil

Beiträge: 10 738

Beruf: Teamleiter Mobile Applikationen & Senior Software Engineer

  • Private Nachricht senden

4

05.03.2015, 13:31

Das kannst Du mit == allein so natürlich nicht überprüfen. Überhaupt verschiedene Unterklassen vergleichen zu wollen klingt nach einer Fehlentscheidung im Design.
Teamleiter von Rickety Racquet (ehemals das "Foren-Projekt") und von Marble Theory

Willkommen auf SPPRO, auch dir wird man zu Unity oder zur Unreal-Engine raten, ganz bestimmt.[/Sarkasmus]

5

05.03.2015, 13:42

Ich möchte keine unterschiedlichen Unterklassen vergleichen. Das hier ständig das Stichwort Designfehler in den Raum geworfen wird, hilft hier recht wenig. Ich würde nicht fragen, wäre ich von meiner Methode vollends überzeugt. Deswegen wäre ein Beispiel oder sowas ganz nett, wie man es stattdessen lösen könnte. Ich finde, ich habe die Problemstelle sehr gut runter gebrochen, sodass man mich hier nicht auf das "Design" festnageln muss.

Nochmal zum Verständnis, was meine Vorgaben sind:

- 2 Objekte vom gleichen Typ auf Gleichheit prüfen
- Alle Member der beiden Objekte müssen identisch sein (auch die der Oberklassen)

Ich möchte dafür einen geeigneten Weg finden. Das was ich oben gezeigt habe, war lediglich ein Vorschlag, wie ich es erstmal angehen würde, um mir für jede Unterklasse eine separate operator Überladung zu ersparen.

mfg

Sacaldur

Community-Fossil

Beiträge: 2 301

Wohnort: Berlin

Beruf: FIAE

  • Private Nachricht senden

6

05.03.2015, 13:50

Um beurteilen zu können, ob der angestrebte Vergleich wirklich sinnvoll/erforderlich ist, wäre ein konkretes Beispiel erforderlich.
Oder um's anders zu formulieren: frage bitte nach Lösungsansätzen für dein _eigentliches_ Problem, nicht für Verbesserungsvorschläge für den Lösungsansatz, den du bisher für dein eigentliches Problem verfolgt hast.
Spieleentwickler in Berlin? (Thema in diesem Forum)
---
Es ist ja keine Schande etwas falsch zu machen, als Programmierer tu ich das täglich, [...].

dot

Supermoderator

Beiträge: 9 757

Wohnort: Graz

  • Private Nachricht senden

7

05.03.2015, 14:03

Genau das möchte ich ja erreichen. Da von foo öfter geerbt wird, will ich verhindern, dass 2 unterschiedliche Klassen miteinander verglichen werden. es sollen die fertigen Objekte und nicht irgendwelche unfertigen Oberklassen verglichen werden.

Dann mach keinen operator== für Foos sonder einen bool operator==(const Bar& lhs, const Bar& rhs)!? Wieso brauchst du das virtual bool compare()? Das schaut mir alles sehr merkwürdig aus, was genau ist das konkrete Problem, das du lösen willst?

8

05.03.2015, 14:10

Ok, dann eben nochmal ein bisschen drumherum.

Ich habe einen vector<Bar>, welcher zu einer Klasse "Container" gehört. Jedes Objekt in diesem vector hat eine ID, die dem Index + 1 entspricht.
Durch die Funktionsweise des Programms, erstelle ich ein Objekt von Bar. Hier kann natürlich auch ein Objekt mit einer ID herauskommen, welches schon existiert.
Nun möchte ich herausfinden, ob ein Unterschied zum bereits bestehenden Objekt besteht und ich es als verändert "markieren" soll, oder ob ich es einfach verwerfen kann.

Da "Foo" die Basisklasse für mehrere child Klassen ist, möchte ich redundanten Code natürlich vermeiden. Darum versuche ich die Member über die oben gezeigte Methode zu vergleichen.

C-/C++-Quelltext

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
class Foo
{
public:
    int ID = 0;
    // weitere member
};

class Bar : public Foo
{
    int y = 0;
    // weitere member
};

class Bar2 : public Foo
{
    float xyz = 0;
    // weitere member
};
// weitere Unterklassen von Foo

template <class T>
class Container
{
    std::vector<T> m_Vector;
    
public:
    void setObject(const T& obj)
    {
        // ...
        if (m_Vector.at(obj.ID + 1) != obj)           // <<< Problemstelle
            // tue etwas damit
        // ...
    }
}


Vom Prinzip her ist es das, was momentan vorliegt.

Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von »anti-freak« (05.03.2015, 14:15)


dot

Supermoderator

Beiträge: 9 757

Wohnort: Graz

  • Private Nachricht senden

9

05.03.2015, 14:15

Wäre es nicht besser, die Sache mit dem vector in einem eigenen Foo Container zu kapseln, anstatt so umständlich mit irgendwelchen virtuellen Methoden und wild überladenen operator== rumzumachen? ;)

10

05.03.2015, 14:17

Genau das möchte ich ja erreichen. Da von foo öfter geerbt wird, will ich verhindern, dass 2 unterschiedliche Klassen miteinander verglichen werden. es sollen die fertigen Objekte und nicht irgendwelche unfertigen Oberklassen verglichen werden.

Dann mach keinen operator== für Foos sonder einen bool operator==(const Bar& lhs, const Bar& rhs)!? Wieso brauchst du das virtual bool compare()? Das schaut mir alles sehr merkwürdig aus, was genau ist das konkrete Problem, das du lösen willst?


Das wäre dann jetzt auch mein Vorschlag.

Ich hatte früher mal die Frage gestellt warum Operatoren Global überladen werden (Bei Klassen des selben Typs).
Das wäre jetzt für mich der einzige Grund das Global zu machen (meine damalige Frage konnte für mich nie zufriedenstellend beantwortet werden).
Wer aufhört besser werden zu wollen hört auf gut zu sein!

aktuelles Projekt:Rickety Racquet

Werbeanzeige