Wenn Du Deinen Vektor mit vector<A*> anlegst, ist ein kleiner automatisch für den Pointer definiert und er sortiert danach. Ansonsten gibt es einen Compile-Fehler.

Wie kann ich bewirken, dass sort beim sortieren eines vectors von Objekten meiner Klasse A den operator</> meiner Klasse benutzt?

den operator überladen
bsp: http://tutorial.schornboeck.net/operatoren_ueberladung.htm

__gast schrieb:

Und ergibt der Aufruf keinen Fehler, wenn ich keinen definiere?

ja

__gast schrieb:

Wie wird dann sortiert?

http://www.cppreference.com/cppalgorithm/sort.html

bool operator<(MyClass& a,MyClass& b)
{
  return true;
}

bool operator>(MyClass& a,MyClass& b)
{
  return true;
}

implementiert.
Trotzdem gibt es bei Benutzung von sort einen Fehler in _function_base.h

template <class _Tp>
struct less : public binary_function<_Tp,_Tp,bool> 
{
  bool operator()(const _Tp& __x, const _Tp& __y) const { return __x < __y; }
};

[C++ Error] _function_base.h(73): E2093 'operator<' not implemented in type 'MyClass' for arguments of the same type

Wieso das?

Wenn Du vector<A*> benutzt, wird niemals A::operator< aufgerufen, sondern A*::operator <, was nur die Pointer vergleicht.
Deswegen übergibst Du sort dann ein Objekt, welches den Vergleich erledigt (auf Pointer Basis).

bool CompareAPtr(const A* a,const A* b)
{
   return true;
}

int main()
{
  vector<A*> x;

  sort( x.begin(), x.end(), ptr_fun( CompareAPtr));
}

bool operator<(MyClass& a,MyClass& b)
{
return true;
}
// Sollte doch einfach so aussehen
bool operator< (const MyClass& a, const MyClass& b)
{
return true;
}

Dann sollte das auch ganz ohne Prädikat (diese Vergleichsklasse hier) gehen, gibt ja nicht umsonst vorgefertigte wie std::less

MfG SideWinder

Kurzform:

f(x, x) -> false.
f(x, y) -> !f(y, x)
f(x, y) und f(y, z) -> f(x, z)

Insbesondere wichtig, wenn man so ein Prädikat in Maps oder Sets einsetzt. Sonst sind die potenziell intern Schrott.

MfG SideWinder

class A {
};

int main()
{
   vector<A*> x;
   sort( x.begin(), x.end());
}

?
In dem Fall wird less<A*>() aufgerufen, d.h. in etwa eine so aussehende Funktion:

bool less<A*>( const A* a, const A* b) 
{
   return a < b;
}

d.h. es wird nicht A::operator<() aufgerufen.
Obiges Beispiel compiliert, während die Variante mit vector<A> aufgrund des fehlenden A::operator< nicht compiliert.