ich habe ne klasse Sorter, von der verschiedene sortieralgorithmen ableiten und die abstrakte virtuelle funktion DoSort ueberschreiben um dort das sortierverfahren zu implementieren. zur zeit sortieren alle aufsteigend. um nun auch nach anders sortieren zu können (absteigend oder nach anderen kriterien) wollte ich die klasse um eine functor erweitern (siehe unten) den ich dann beim aufruf uebergebe und der den vergleich uebernimmt.

problem ist nun das virtual von DoSort. mein compiler mosert rum, das virtual und template (template <typename Functor> nicht zusammen funktionieren. aber ohne diese kann ich ja den functor nicht an die ableitende klasse uebergeben.

wie löse ich dieses problem am besten?

template <typename T>
class Sorter
{
  protected:

    // elemente vertauschen
    virtual void Swap(T *a, T *b);

    template <typename Functor >
    virtual void DoSort(T *Left, T *Right, Functor Compare) = 0;

  public:

    template <typename Functor >
    void Sort(T *Left, T *Right, Functor Compare);
};

// Shell-Sort
template <typename T>
class ShellSorter : public Sorter<T>
{
  protected:

//    void DoSort(T *Left, T *Right);

    template <typename Functor>
    void DoSort(T *Left, T *Right, Functor Compare);
};

template <typename T>
class Less
{
  public:

    // Funktionsoperator
    bool operator () (const T &lhs, const T &rhs) const 
    { 
      return (lhs < rhs); 
    }
};

p.s. gleich vorne weg nein ich will kein std::sort verwenden!

template<typename T>
class Sorter
{
  protected:

    // elemente vertauschen
    virtual void Swap(T *a, T *b);

    template<typename Functor>
    virtual void DoSort(T *Left, T *Right, Functor Compare) = 0;

  public:

    template<typename Functor>
    void Sort(T *Left, T *Right, Functor Compare);
};

Wenn das nicht funktioniert, kannst du höchstens noch "typename Functor=Less<T>" als zweiten Parameter der Sorter-Klasse angeben.

template<typename T,typename Functor=Less<T>
struct sorter{...}

c) du baust dir einen Vergleichsoperator, der (halb)dynamisch sein Verhalten ändern kann:

template<typename T>
class compare{
  const bool less;
public:
  compare(bool n_less) : less(n_less) {}
  bool operator()(const T& lhs,const T& rhs) const
  { return less ? lhs<rhs : lhs>rhs; }
}

//...
mySorter.Sort(start,end,compare<char>(true));//sortiere char's steigend
mySorter.Sort(start,end,compare<char>(false));//sortiere char's fallend

template <typename T>
class Greater
{
  public:

    // Funktionsoperator
    bool operator () (const T &lhs, const T &rhs) const 
    { 
      return (lhs > rhs); 
    }
};

aiLibBasics::Greater<int>       G;
ShellSorter<int, Greater<int> > S;

S.Sort(Liste + 0, Liste + LaengeListe - 1, G);

ist das so gedacht oder stehe ich heute nur extrem aufm schlauch?

hi,
ich habe ne klasse Sorter, von der verschiedene sortieralgorithmen ableiten

schlechte idee.
klassen, die keine attribute haben und nur eine methode, sind eigentlich funktionen. also mach auch funktionen.
die dann per funktor-wrapper in eine liste stecken, wird ein anderes (einfaches) problem.