struct SetElem{
float Elem1;
int Elem2;
int Elem3;
}

std::set< SetElem > MySet;

Wenn das set jetzt gefüllt wird (Myset.insert(...)), wie kann ich das Set nach einem der drei Elemente ordnen lassen?

Ideen wären fett!

ANGS_Pino

Das Vergleichsobjekt muß als Rückgabetyp einen bool liefern und 2 Argumente des zu vergleichenden Objektes akzeptieren.

Der Aufbau eines solchen Vergleichsobjektes (auch als Prädikat,Funktionsobjekt oder Functor bezeichnet) sieht im allgemeinen so aus:

class meinVergleich: public std::binary_function<meinTyp, meinTyp, bool>
{
   bool operator() (const meinTyp& left, const meinTyp& right) const;
};

bool meinVergleich::operator() (const meinTyp& left, const meinTyp& right) const
{
// hier findet der selbstdefinierte Vergleich statt
};

Das Ableiten von der Basisklasse 'binary_function' ist nicht unbedingt notwendig. In dieser Basisklasse werden den Datentypen der Argumente und Rückgabewerte standardisierte Namen gegeben, was später die Verwendung von Bindern ermöglicht. Die Klasse 'binary_function' ist in der Header-Datei 'functional' definiert.

die Deklaration des Set erfolgt dann folgendermaßen:

std::set<meinTyp, meinVergleich> meinSet

template <class T, class M, class Compare = std::less<M> >
struct MemCompare
{
  typedef typename M T::*MemPtr;

  MemCompare(MemPtr const memPtr, Compare cmp = Compare()) : comp(cmp), mem(memPtr) {}

  bool operator()(T const& lhs, T const& rhs) { return comp(lhs.*mem, rhs.*mem); }

private:
  Compare comp;
  MemPtr mem;
};

template <class T, class M, class Compare>
MemCompare<T,M,Compare> memCompare(M T::* memptr, Compare cmp)
{
  return MemCompare<T,M,Compare>(memptr, cmp);
}

template <class T, class M>
MemCompare<T,M> memCompare(M T::* memptr)
{
  return MemCompare<T,M>(memptr);
}

//Benutzungsbeispiel:

struct A
{
   A(int i) : t(i) {}
public:
   int t;
   float u;
   char v;
};

int main()
{
  std::set<A, MemCompare<A,int> > mySet(memCompare(&A::t));
  mySet.insert(A(5));
  mySet.insert(A(1));
  mySet.insert(A(22));

  for (std::set<A, MemCompare<A,int> >::iterator it = mySet.begin(); it != mySet.end(); ++it)
     std::cout << it->t << " ";
  std::cout << std::endl;
}

(Vermutlich etwas Overkill für die Situation, man kanns aber immer wieder mal gebrauchen)

Braunstein: Operator< für die structs zu überladen ist nur dann sinnvoll wenn das dann eine verständliche Ordnungsrelation ergibt. Den Operator zu überladen nur damit std::set automatisch einen Comparator hat ist nicht der richtige Weg (siehe den Artikel zur Operatprüberladung)

Wenn es keine verständliche Ordnungsrelation gibt ist, meiner Meinung nach, auch eine Einordnung in ein set nicht sinnvoll, da die Existenz einer solchen hier erforderlich ist.

Es gibt auch Fälle, wo man eine Sortierung haben möchte, aber operator< dafür nicht intuitiv scheint.

Einfaches Beispiel: Klasse, die nach mehreren Kriterien sortiert werden kann. Oder halt Klassen, bei denen man nur durch Raten auf die Bedeutung der Kleiner-Relation kommt (z.B. 2D-Vektoren).