ich hab 2 klassen

template <typename T>
struct Blah_1 
{
  // Funktionsoperator
  void operator () (T &rhs) 
  {
    // ...
  }
};

template <typename T>
struct Blah_2 :
{
  // Funktionsoperator
  void operator () (T &rhs)
  {
    // ...
  }
};

je nachdem was im programm anfaellt ueber gebe ich einer funktion dann eine dieser beiden klassen:

template <typename T> 
template <typename Functor>
void Class_1<T>::BlahFasel_Func(/* Parameterlistr */, Functor Func)
{
  // Aufruf
  Func(/*Wert*/);
}

aufrufen tue ich das bisher so, hab immer alles doppelt (gerade bei schleifen unschoen).

template <typename T> 
void Class_1<T>::BlahFasel(/* Parameterlistr */)
{
  if (Irgendwas)
  { 
    Blah_1<T> Func;

    // Aufruf (Bsp)
    for (int i = 0; i < 1000; ++i)
      BlahFasel_Func(/*Parameter*/, Func);
  }
  else
  {
    Blah_2<T> Func;

    // Aufruf (Bsp)
    for (int i = 0; i < 1000; ++i)
      BlahFasel_Func(/*Parameter*/, Func);
  }
}

wie kann ich den aufruf von BlahFasel_Func nur noch einmal schreiben, also so:

template <typename T> 
void Class_1<T>::BlahFasel(/* Parameterlistr */)
{
  if (Irgendwas)
  { 
    Blah_1<T> Func;
  }
  else
  {
    Blah_2<T> Func;
  }

  // Aufruf
  for (int i = 0; i < 1000; ++i)
    BlahFasel_Func(/*Parameter*/, Func);
}

irgendwie klappt das nicht, wenn ich fuer Blah_1 und Blah_2 ne basisklasse definiere von der beide erben, da dann der operator nicht aufgerufen wird.

dann mach ich folgendes:

BasisBlah<T> *Func;

if (Irgendetwas) Func = new Blah_1<T>;
else             Func = new Blah_2<T>;

BlahFunc(/*Parameter*/, Func);

damit bekomme ich dann nen Fehler wegen abstrakter Klasse.

template <typename T> 
template <typename Functor>
void BlahFunc(/*Parameter*/, Functor Func)
{ 
  Func(/*Wert*/);
}

irgendwie steh ich grad aufm schlauch..