*- ich habe eine Klasse geschrieben, die einen x und einen y Wert als Eigenschaft besitzt

- ich habe eine zweite Klasse die die Eigenschaften der ersten Klasse grafisch darstellen soll und dazu aber den größten x und y Wert der Klasse benötigt*

Jetzt wollte ich den "größer als" Vergleichsoperator der ersten Klasse Überladen, ungefähr so:

bool operator>( const Class1 *c1 ) {

    return( this->xValue > c1->xValue );
}

Wenn ich das gleiche Spiel noch einmal für den y Wert mache, weiß der Compiler dann auch für welchen der beiden Werte er den Vergleich anstellen soll?

Oder kann ich das dann so schreiben:

c1.xValue > c2.xValue und c1.yValue > c2.yValue

So wär es ja dann klar.

Aller dings kann ich dies ja nicht noch mal ein 2. Mal definieren. Hm..?
Gruß Tobi.

Und du benötigst dafür eine sog. "Strict Weak Ordering", d.h. du kannst nicht gleichzeitig nach x und y sortieren lassen, sondern höchstens z.B. erst nach x und dann (bei Gleichheit von x) nach y.

bool operator <( const ClassXY *c1 ) const
{
    return this->xValue < c1->xValue ||
           (this->xValue == c1->xValue && this->yValue < c1->yValue);
}

Wenn du aber jeweils den größten x und y Wert für deine grafische Anzeige benötigst, so solltest du dir mal die Funktion std::max_element aus <algorithm> anschauen (ich gehe mal davon aus, daß du irgendwo eine Liste (Vector) von den Objekten der 1. Klasse hast).

Du kannst dann einfach 2 (statische) Funktionen zum Vergleich der Funktion mitgeben:

bool ClassXY::LessX(const ClassXY &xy1, const ClassXY &xy2) // static in class-declaration
{
  return xy1.xValue < xy2.xValue;
}

// same for LessY (but use yValue)

// in class Graph
std::vector<ClassXY> v;
int maxValueX = *max_element(v.begin(), v.end(), &ClassXY>::LessX); // use dereference
int maxValueY = *max_element(v.begin(), v.end(), &ClassXY>::LessY); // use dereference

bool operator <( const ClassXY *c1 ) const
{
    return this->xValue < c1->xValue ||
           (this->xValue == c1->xValue && this->yValue < c1->yValue);
}

Wenn du den Vergleichsoperator so schreibst, muss er doch eine Methode und keine freie Funktion sein (oder halt zwei Parameter statt nur einem haben). Ok, könnte sein, dass der Code innerhalb der Klasse stehen soll

Außerdem würde man doch keinen Zeiger, sondern eine Referenz als Parameter nehmen

Felix

void m_AddNewGraph( const CGraph *cGraph ) {

    this->m_GraphContainer.push_back( &cGraph );
}

der Container ist so definiert:
std::list < CGraph > m_GraphContainer;

Will ich jetzt aber ein Objekt aufnehmen, das via new erstellt wurde bekomm ich nen Fehler. Kann mir wer sagen wo ran das liegt? Denn ich will ja nicht jedes mal wieder nen neues Objekt erstellen sondern nur die Pointer im container haben.

Gruß Tobi.

ansonsten ist es immer hilfreich, wenn du auch schreibst, was in der fehlermeldung drinsteht.

bool ClassXY::operator <( const ClassXY &c1 ) const
{
    return xValue < c1.xValue ||
           (xValue == c1.xValue && yValue < c1.yValue);
}

Nun zu TObi:
Wenn du nur Zeiger verwenden willst, dann muß deine Methode so aussehen:

void AddNewGraph( const CGraph *cGraph ) // kein m_ bei Methodennamen
{
    this->m_GraphContainer.push_back( cGraph );
}

Ich würde aber, sofern du keine Polymorphie bzw. sehr große Objekte verwendest, trotzdem einfach die Objekte selber im Container speichern.
Ansonsten mußt du dich selber um die Speicherfreigabe kümmern oder aber alternativ z.B. Boost::shared_ptr<> einsetzen.

danke euch,

Gruß Tobi.