ich möchte den operator< für eine Klasse überladen, um die später in einem vector gespeicherten Objekte mittels std::sort sortieren zu können.

Seien also z.B. dies meine Objekte:

CMyObject* pMyObj1 = new CMyObject(/*...*/);
CMyObject* pMyObj2 = new CMyObject(/*...*/);
//etc.

und dies mein überladener Operator:

CMyObject::operator<(const CMyObject&) const
{
    if(/*...*/)
        return true;
    else
        return false;
}

Dann funktioniert folgender Aufruf wunderbar:

bool temp = *pMyObj1 < *pMyObj2;

Allerdings hatte ich eigentlich vor, meine Objekte im Container als CMyObject* abzulegen, was dazu führen würde, dass mein überladener Operator leider nicht mehr so ohne weiteres funktioniert. Ein paar Fragen hätte ich deshalb:

1. Ist es sinnvoll die Objekte (deshalb) "dereferenziert" im Container abzulegen (also z.B. als *pMyObj1)?

2. Oder sollte ich mir eher eine Vergleichsfunktion (bzw. Funktor) bauen und die überladene Variante von std::sort verwenden?

3. Oder kann ich es irgendwie bewerkstelligen, dass ich den operator< so überlade, dass er im Fall von pMyObj1 < pMyObj2 funktioniert?

Welche dieser Vrianten ist also vorzuziehen (falls sich das überhaupt so pauschal sagen lässt)?

Danke im Voraus!

Warum willst du deine Objekte eigentlich als Pointer in den vector packen? Wenn das notwendig ist, würde ich Variante2 nehmen. Du könntest zwar auch einen operator< für Pointer auf CMyObject erzeugen (global), das verändert aber das Standardverhalten von Pointervergleichen. Ich würde das nicht tun.
Desweiteren würde ich an deinen Stelle den operator< lieber außerhalb der Klasse (global) definieren).

Braunstein schrieb:

Warum willst du deine Objekte eigentlich als Pointer in den vector packen?

Wenn ich ehrlich bin, weiß ich das eigentlich selbst nicht so genau . Obwohl das in diesem Fall kein Thema ist, hatte ich da so Sachen wie Polymorphismus im Hinterkopf und dachte das sei deshalb vielleicht (ganz allgemein) die "elegantere" Variante Oder ist das völliger Quatsch?

Braunstein schrieb:

Du könntest zwar auch einen operator< für Pointer auf CMyObject erzeugen (global), das verändert aber das Standardverhalten von Pointervergleichen.

Ok, das klingt logisch und überzeugt mich. Die Variante ist damit aus dem Rennen.
Eine Rückfrage hätte ich dazu trotzdem: Für pointer auf CMyObject kann ich den Operator nur global überladen, richtig? Ich glaube, das war der Grund, warum ich nicht wusste wie man das anstellt, weil ich nur daran gedacht habe das in einer Elementfunktion der Klasse zu machen.

Braunstein schrieb:

Desweiteren würde ich an deinen Stelle den operator< lieber außerhalb der Klasse (global) definieren).

Gibt es dafür einen Grund, ist das für sämtliche Operatoren üblich? Was spricht dagegen das innerhalb der Klasse zu tun?

MyDoub ma, mb;
double da, db;
// sind dann irgendwie gefüllt
// Dann ist folgendes mit einem globalen operator< möglich
if( ma < mb )
if( ma < da )
if( db < mb ) //etc.

1. Ist es sinnvoll die Objekte (deshalb) "dereferenziert" im Container abzulegen (also z.B. als *pMyObj1)?

Nur zum Sortieren ganz sicher nicht. Wenn es aus anderen Gründen Sinn macht, wieso nicht, aber sicht nicht bloss damit du std::sort verwenden kannst.

2. Oder sollte ich mir eher eine Vergleichsfunktion (bzw. Funktor) bauen und die überladene Variante von std::sort verwenden?

Jupp. Würde ich so machen.

3. Oder kann ich es irgendwie bewerkstelligen, dass ich den operator< so überlade, dass er im Fall von pMyObj1 < pMyObj2 funktioniert?

Wäre mir nicht bekannt wie das gehen sollte. Du könntest höchstens std::less spezialisieren, aber das würde ich auf keinen Fall tun. Pfui Spinne.

Welche dieser Vrianten ist also vorzuziehen (falls sich das überhaupt so pauschal sagen lässt)?

Danke im Voraus!

Ich würde auf jeden Fall Version 2 vorschlagen.

Ob du zusätzlich noch Vergleichsoperatoeren anbieten solltest hängt davon ab was das für Klassen sind. Ich implementiere Vergleichsoperatoeren auf jeden Fall nur dann wenn sie Sinn machen (d.h. auch gut gebraucht werden können), wenn klar ist was verglichen wird, und wenn sie "strict ordering" implementieren.

Zweitens: Den op< für Objekt-Vergleich kannst du wahlweise als Member oder als globale Funktion definieren - letzteres hat den Vorteil, daß der linke Operand auch etwas nach CMyObject konvertierbares sein darf. Wenn er Sinn macht, würde ich das tun (und die Vergleichs-Funktion dann als bool compare(T* left,T* right){return *left<*right;} darauf aufbauen).

Drittens:

Nanuq schrieb:

CMyObject::operator<(const CMyObject&) const
{
    if(/*.. Bedingung ..*/)
        return true;
    else
        return false;
}

Warum so umständlich? Statt die Vergleichsbedingung auszuwerten, kannst du ihr Ergebnis auch direkt ausgeben:

bool operator<(const CMyObject& left,const CMyObject& right)
{
  return /*.. Bedingung ..*/;
}

Viertens: Pointer zu speichern kann durchaus Sinn machen (Polymorphismus, Aufwand für Objekt-Kopie, Mehrfachnutzung von Objekten,...) - aber du solltest dir klar sein, daß du dann selber dafür verantwortlich bist, den Speicher zu verwalten. (an der Stelle wären vector<boost::shared_ptr<T> > oder Boost's Pointer-Container eine gute Alternative)

CStoll schrieb:

Erstens: den op< für einen reinen Pointer-Vergleich darfst du gar nicht überladen (wie Braunstein sagte, würde das mit dem Standardvergleich kollidieren und ist deshalb verboten).

Das leuchtet mir inzwischen volkommen ein, war ein wertvoller Hinweis!

CStoll schrieb:

Warum so umständlich? Statt die Vergleichsbedingung auszuwerten, kannst du ihr Ergebnis auch direkt ausgeben

Im tasächlichen Fall werden mehrere Kriterien überprüft. Ich habe deshalb ein paar verschachtelte if/else-Blöcke von denen bei der Zusammenfassung für dieses Posting dann irgendwie nur noch dieser Codeschnipsel übriggeblieben ist...

CStoll schrieb:

Viertens: Pointer zu speichern kann durchaus Sinn machen (Polymorphismus, Aufwand für Objekt-Kopie, Mehrfachnutzung von Objekten,...) - aber du solltest dir klar sein, daß du dann selber dafür verantwortlich bist, den Speicher zu verwalten. (an der Stelle wären vector<boost::shared_ptr<T> > oder Boost's Pointer-Container eine gute Alternative)

Dann war ja mein erster Gedanke gar nicht so verkehrt

Nanuq schrieb:

Polymorphismus

:p *freu* :p
Dass ich mich um die Speicherverwaltung dann selbst kümmern muss, ist mir klar, ob ich mich deswegen einmal etwas eingehender mit boost befasse noch nicht so ganz
Aber danke für den Hinweis.

hustbaer schrieb:

2. Oder sollte ich mir eher eine Vergleichsfunktion (bzw. Funktor) bauen und die überladene Variante von std::sort verwenden?

Jupp. Würde ich so machen.

Ich denke, darauf wird es hinauslaufen.