z.B.:

class Klasse
{
public:
int val1, val2;
}

mit

struct compareVal1
{
  bool operator()(const Klasse& ref1, const Klasse& ref1) 
  { return a.val1< b.val1; }
};
struct compareVal2
{
  bool operator()(const Klasse& ref1, const Klasse& ref1) 
  { return a.val2< b.val2; }
};

okay, soweit so gut. Alternativ läßt sich auch der Vergleichsoperator überladen, wobei der sich nur für eine Vergleichssorte überschreiben läßt (val1 oder val2, oder man verbockt sich dass irgendwie mit if anweisungen...)

naja, nun hängen viele kleine zusätzliche structs rum. meist mache ich daraus nested classes, damit man sie besser zurordnen kann.

aber kann man das ganze nich tirgendwie in ein template packen?

template<int (Klasse*::Member)>//ich hoffe, die Syntax hier ist richtig
struct compare
{
  bool operator()(const Klasse&r,const Klasse&l)
  { return r.*Member < l.*Member; }
};

sort(l.begin(),l.end(),compare<&Klasse::val1>());

template< typename T, typename MemT >
struct CompareValT
{
        typedef MemT ( T::*member_type );

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

        CompareValT( member_type member ): m_member( member ) {}

private:
        member_type m_member;
};

template< typename T, typename MemT >
CompareValT< T, MemT > CompareVal( MemT (T::*member) )
{
        return CompareValT< T, MemT >( member );
}

using namespace std;

int main()
{
        vector< Klasse > k;
        sort( k.begin(), k.end(), CompareVal( &Klasse::Val1 ) );
        sort( k.begin(), k.end(), CompareVal( &Klasse::Val2 ) );
}

Die Funktion CompareVal dient nur dazu sich die automatische Deduktion der Templateparameter zunutze zu machen

EDIT:
CStolls Version funktioniert natürlich auch.

template<int (Klasse*::Member)>//ich hoffe, die Syntax hier ist richtig

fast

template<int (Klasse::*Member)>

Danke

@CStoll: die Version klappt aber nur für int-Werte, oder? bzw. wie schaut das ganze bei floats oder double werten aus, die nach wie vor noch nicht bei templates erlaubt sind?

muffmolch schrieb:

@CStoll: die Version klappt aber nur für int-Werte, oder? bzw. wie schaut das ganze bei floats oder double werten aus, die nach wie vor noch nicht bei templates erlaubt sind?

Hier ist weder int, noch double, noch float ein Templateparameter. Der Templateparameter ist ein (Methoden-)Zeiger und könnte auch auf eine Memberfunktion zeigen, die ein float, string und Point entgegennimmt und einen vector< tuple< char, short, int, long > > zurückgibt (Achtung: Beispiel überzogen :D)

@CStoll: die Version klappt aber nur für int-Werte, oder? bzw. wie schaut das ganze bei floats oder double werten aus, die nach wie vor noch nicht bei templates erlaubt sind?

Ja, das war auch auf das wesentliche beschränkt - natürlich kannst du die übrigen Bestandteile auch als Template-Parameter festlegen:

template<typename K, typename M, M (K::*Member)>
struct Compare
{...};

Hier ist weder int, noch double, noch float ein Templateparameter. Der Templateparameter ist ein (Methoden-)Zeiger und könnte auch auf eine Memberfunktion zeigen, die ein float, string und Point entgegennimmt und einen vector< tuple< char, short, int, long > > zurückgibt (Achtung: Beispiel überzogen :D)

Oehm nein. Der Template-Parameter ist ein Zeiger namens Member, der auf einen int innerhalb der Klasse namens Klasse zeigt. Dein Beispiel wuerde so aussehen:

template< vector< tuple< char, short, int, long > > (MeineKlasse::(*Member)(float, string, Point)) >

//oder schoener:
typedef vector< tuple< char, short, int, long > > Ergebnis;
typedef Ergebnis MeineKlasse::(*KrasserFktPtr)(float, string, Point);
template<KrasserFktPtr Member>

Der template-parameter ist nich "irgendein" Pointer, sondern ein Pointer eines bestimmten Typs. Und diesen Typ gibst du mit an. Um etwas weniger kompizierte Beispiele zu verwenden, folgendes ist verschieden:

template <void* ptr> //Zeiger auf void, wer haetts gedacht
template <int* pInt>
template <void (*fktPtr)()> //zeiger auf Funktion mit Rueckgabe void ohne parameter
template <int C::*memPtr> //zeiger auf int in Klasse C, siehe CStolls Bsp
template <void C::(*memFktPtr)()> //zeiger auf void-Funktion ohne Parameter in KLasse C

Oehm nein. Der Template-Parameter ist ein Zeiger namens Member, der auf einen int innerhalb der Klasse namens Klasse zeigt. Dein Beispiel wuerde so aussehen

Du hast recht, es ist kein "Methodenzeiger", sondern ein "Memberzeiger". An dem Rest halte ich jedoch fest (ändert ja nichts daran dass ein Zeiger auf ein float-Member immernoch ein konstanter Zeiger und damit ein gültiger Templateparameter ist).

Nur wie?

dann sollte das ganze auch mit get-Methoden funktionieren, wenn man eh nur Funktionspointer übermittelt. Sehe ich das richtig? also wenn z.B. kein direkter Zugriff auf die Member klasse möglich ist und man die friend deklaierung vermeiden möchte:

class Klasse
{
public: 
   ...
   double getVal1();
   double getVal2();
   ...
private:
   double val1,val2;

also in etwas so:

template<typename K, typename M, M (K::*fct)> 
struct compare 
{ 
  bool operator()(const K&r,const K&l) 
  { return r.*fct< l.*fct; } 
}; 

sort(l.begin(),l.end(),compare<Klasse, &Klasse::getVal1>());

template<typename K, typename M, M (K::*fct)()>  //die Klammern hinten machen den unterschied zwischen Funktion und normalem Member
struct compare 
{ 
  bool operator()(const K&r,const K&l) 
  { return r.(*fct)()< l.(*fct)(); }   //hier bedeuten die Klammern den Aufruf des opertor(), im Funktionspointer-Fall also der entsprechenden Funktion
};

Da fehlten Funktionsklammern an 3 Stellen, sonst duerfte es aber so funktionieren.

@pumuckl: Ja, ich hätte mir auch gewünscht, das alles auf einen Parameter zu reduzieren, aber das gibt C++ nicht her.

Wartmal. geht nicht sowas:

template <class C, typename M>
sruct compare {
  typedef M C::*MemPtr;
  compare(MemPtr ptr) : mp_(ptr);
  bool operator()(C& l, C& r) {return l.(*mp_) < m.(*mp_);}
private:
  MemPtr mp_;
};

template <class C, typename M> //template argument deduction
compare<C,M> make_compare(M C::*ptr) {compare<C,M> cmp(ptr); return cmp}

sort(l.begin(),l.end(),make_compare(&Klasse::Member));

Wupp, schon muesste es gehn...

template<class C, typename E>
struct fkt_compare {
  typedef M C::(*MemFktPtr)();
  compare(MemFktPtr ptr) : mfp_(ptr);
  bool operator()(C& l, C& r) {return l.(*mp_)() < m.(*mp_)();}
private:
  MemPtr mfp_;
};

template <class C, typename M> //template argument deduction again
fkt_compare<C,M> make_compare(M C::(*ptr)()) {fkt_compare<C,M> fcmp(ptr); return fcmp}

Damit kann make_compare auch ein Funktionspointer uebergeben werden, gleichzeitiges Ueberladen von Funktionstemplate mit template argument deduction

class Klasse{
public:
   Klasse(int val1, int val2 ) : val1(val1),val2(val2) {}
//   int getVal1() const { return val1; }
//   int getVal2() const { return val2; }
//private:
   int val1, val2;
};
template<typename K, typename M, M (K::*Member)> 
struct compareMember 
{ 
   bool operator()(const K &r, const K &l) 
   { return r.*Member < l.*Member; } 
}; 
int main(){
   list<Klasse> l;
   l.push_back(Klasse(10,10));
   l.push_back(Klasse(1,5));
   l.push_back(Klasse(50,3));
   sort(l.begin(),l.end(),compareMember<Klasse, int,  &Klasse::val1>());
};

endet in folgendes compilerfehlermeldungen:

C:\Program Files\Microsoft Visual Studio 8\VC\include\algorithm(3261) : error C2784: 'reverse_iterator<_RanIt>::difference_type std::operator -(const std::reverse_iterator<_RanIt> &,const std::reverse_iterator<_RanIt2> &)' : could not deduce template argument for 'const std::reverse_iterator<_RanIt> &' from 'std::list<_Ty>::_Iterator<_Secure_validation>'
with
[
_Ty=Klasse,
_Secure_validation=true
]
C:\Program Files\Microsoft Visual Studio 8\VC\include\xutility(1856) : see declaration of 'std::operator -'
F:\LBM_subversion\source\lbmd2q9\a2pII\testcases\inputfileSerial\main.cpp(57) : see reference to function template instantiation 'void std::sort<std::list<_Ty>::_Iterator<_Secure_validation>,compareMember<K,M,Member>>(_RanIt,_RanIt,_Pr)' being compiled
with
[
_Ty=Klasse,
_Secure_validation=true,
K=Klasse,
M=int,
Member=pointer-to-member(0x0),
_RanIt=std::list<Klasse>::_Iterator<true>,
_Pr=compareMember<Klasse,int,pointer-to-member(0x0)>
]
C:\Program Files\Microsoft Visual Studio 8\VC\include\algorithm(3261) : error C2784: 'reverse_iterator<_RanIt>::difference_type std::operator -(const std::reverse_iterator<_RanIt> &,const std::reverse_iterator<_RanIt2> &)' : could not deduce template argument for 'const std::reverse_iterator<_RanIt> &' from 'std::list<_Ty>::_Iterator<_Secure_validation>'
with
[
_Ty=Klasse,
_Secure_validation=true
]
C:\Program Files\Microsoft Visual Studio 8\VC\include\xutility(1856) : see declaration of 'std::operator -'
C:\Program Files\Microsoft Visual Studio 8\VC\include\algorithm(3261) : error C2784: 'reverse_iterator<_RanIt>::difference_type std::operator -(const std::reverse_iterator<_RanIt> &,const std::reverse_iterator<_RanIt2> &)' : could not deduce template argument for 'const std::reverse_iterator<_RanIt> &' from 'std::list<_Ty>::_Iterator<_Secure_validation>'
with
[
_Ty=Klasse,
_Secure_validation=true
]
C:\Program Files\Microsoft Visual Studio 8\VC\include\xutility(1856) : see declaration of 'std::operator -'
C:\Program Files\Microsoft Visual Studio 8\VC\include\algorithm(3261) : error C2784: 'reverse_iterator<_RanIt>::difference_type std::operator -(const std::reverse_iterator<_RanIt> &,const std::reverse_iterator<_RanIt2> &)' : could not deduce template argument for 'const std::reverse_iterator<_RanIt> &' from 'std::list<_Ty>::_Iterator<_Secure_validation>'
with
[
_Ty=Klasse,
_Secure_validation=true
]
C:\Program Files\Microsoft Visual Studio 8\VC\include\xutility(1856) : see declaration of 'std::operator -'
C:\Program Files\Microsoft Visual Studio 8\VC\include\algorithm(3261) : error C2676: binary '-' : 'std::list<_Ty>::_Iterator<_Secure_validation>' does not define this operator or a conversion to a type acceptable to the predefined operator
with
[
_Ty=Klasse,
_Secure_validation=true
]
C:\Program Files\Microsoft Visual Studio 8\VC\include\algorithm(3261) : error C2780: 'void std::_Sort(_RanIt,_RanIt,_Diff)' : expects 3 arguments - 4 provided
C:\Program Files\Microsoft Visual Studio 8\VC\include\algorithm(3085) : see declaration of 'std::_Sort'

Also entweder du verwendest einen anderen Container (vector<> oder deque<>) oder du nutzt die list-Methode sort():

l.sort(compareMember<Klasse, int,  &Klasse::val1>());

class Klasse{
public:
   Klasse(double val1, double val2 ) : val1(val1),val2(val2) {}
   double getVal1() const { return val1; }
   double getVal2()       { return val2; }
private:
   double val1, val2;
};
template<typename K, typename M, M (K::*fct)()>  
struct compareMethods{ 
   bool operator()(const K& r, const K& l) 
   { return r.(*fct)() < l.(*fct)();  }   
}; 
int main(int argc, char** argv)
{
   list<Klasse> l;
   l.push_back(Klasse(10,10));
   l.push_back(Klasse(1,5));
   l.sort(compareMethods<Klasse, double,  &Klasse::getVal1 >() );
   l.sort(compareMethods<Klasse, double,  &Klasse::getVal2 >() );
}

Fehler:

//Fuer l.sort( compareMethods<Klasse, double, &Klasse::getVal1 >() ):
1>main.cpp error C2440: 'specialization' : cannot convert from 'overloaded-function' to 'double (__thiscall Klasse::* )(void)'
//Fuer l.sort(compareMethods<Klasse, double, &Klasse::getVal2 >() ):
1>main.cpp error C2059: syntax error : '(' bei { return r.(*fct)() < l.(*fct)(); 1>while compiling class template member function 'bool compareMethods<K,M,fct>::operator ()(const K &,const K &)'
1> with
1> [
1> K=Klasse,
1> M=double,
1> fct=Klasse::getVal2
1> ]
1>main.cpp (56) : see reference to class template instantiation 'compareMethods<K,M,fct>' being compiled
1> with
1> [
1> K=Klasse,
1> M=double,
1> fct=Klasse::getVal2
1> ]

Zum zweiten Fall: Die Klammern um *fct waren Bloedsinn von mir. Dadurch wird der Member-Pointer_Zugriffsoperator .* zerlegt. Mein Fehler, sry...
also

return r.*fct() < l.*fct();

return (r.*fct)() < (l.*fct)();

Vermutlich muss der linke AUsdruck geklammert werden, damit er erst dessen Rueckgabewert bestimmt (naemlich die Funktion fuer ein spezielles Obejkt), und danach erst den operator() drauf anwendet...

error C2440: 'argument' : cannot convert from 'const Klasse *' to 'Klasse *const '
Conversion loses qualifiers