ich habe einen Vector von pointern auf eine von mir geschiebene Klasse, so ungefähr: vector<myClass *> *myVector

obwohl myClass einen vergleichsoperator enthält sortiert sort die pointer
und nicht mittels meines vergleichsoperators.

Also will ich jetzt ein prädikat definieren, indem ich eine Funktion schreibe:

bool vergleiche(myClass *a, myClass *b)
{
  if(*a < *b ) return true;
  return false;
}

...

void f()
{
   sort(myVector->begin(),myVector->end(), vergleiche);
}

geht aber nicht
kann mir jemand nen tip geben?
Dankeschön.

geht aber nicht

Tolle Fehlerbeschreibung.

Fehlermeldung: in include algorithm: "term does not evaluate to a function taking 2 arguments"

Und hier die stelle die der compiler moniert:

template<class _RanIt,
	class _Pr> inline
	pair<_RanIt, _RanIt> _Unguarded_partition(_RanIt _First, _RanIt _Last,
		_Pr _Pred)
	{	// partition [_First, _Last), using _Pred
	_RanIt _Mid = _First + (_Last - _First) / 2;
	_Median(_First, _Mid, _Last - 1, _Pred);
	_RanIt _Pfirst = _Mid;
	_RanIt _Plast = _Pfirst + 1;

	while (_First < _Pfirst
		&& !_Pred(*(_Pfirst - 1), *_Pfirst)
		&& !_Pred(*_Pfirst, *(_Pfirst - 1)))   //***** hier
		--_Pfirst;
	while (_Plast < _Last
		&& !_Pred(*_Plast, *_Pfirst)
		&& !_Pred(*_Pfirst, *_Plast))
		++_Plast;

	_RanIt _Gfirst = _Plast;
	_RanIt _Glast = _Pfirst;

bool Coord::operator<(Coord a)
{
	if(_x<a.x()) return true;
	else
	{
		if(_x == a.x() && _y<a.y()) return true;
		else
			if(_x==a.x() && _y==a.y() && _z<a.z()) return true;
	}
	return false;
}

struct MyGreater
{
   bool operator()( myClass *a, myClass *b )
   {
      return *a < *b;
   } 
};

std::sort( vec.begin(), vec.end(), MyGreater() );

Edit: btw wundert es mich das es nicht geht. Eigentlich sollte deine Funktion zum Vergleich genauso funktionieren.

Aber versuch mal das:

bool vergleiche(myClass * const & a, myClass * const & b)
{
  return *a < *b;
}

Ok, das ist kappes. Hast du vielleicht noch irgendwo ein vergleiche? Was sagt der Compiler zum Typ von _Pred?

Versuche es mal einfach so:

struct MyGreater
{
   bool operator()( myClass *a, myClass *b )
   {
      return *a < *b;
   } 
};

std::sort( vec.begin(), vec.end(), MyGreater() );

Edit: btw wundert es mich das es nicht geht. Eigentlich sollte deine Funktion zum Vergleich genauso funktionieren.

Hallo,

sollte man da nicht von std::binary_function ableiten bzw. first_argument_type etc.. dabeipacken?

evilissimo schrieb:

Versuche es mal einfach so:

struct MyGreater
{
   bool operator()( myClass *a, myClass *b )
   {
      return *a < *b;
   } 
};

std::sort( vec.begin(), vec.end(), MyGreater() );

Edit: btw wundert es mich das es nicht geht. Eigentlich sollte deine Funktion zum Vergleich genauso funktionieren.

Hallo,

sollte man da nicht von std::binary_function ableiten bzw. first_argument_type etc.. dabeipacken?

Ich denke nicht dass es notwendig ist einen Funktor von std::binary_function abzuleiten. Sollte ich mich irren lasse ich mich gerne mit Quellenangabe eines besseren belehren

BR
evilissimo

Quellenangabe wäre "The C++ Standard Library - A tutorial and reference", S.310.