Folgender Code funktioniert verständlicherweise nicht.

template<class T>
struct Foo
{
    /* Andere Member / Methoden */
    virtual void F(T const&) const = 0;
};
template<>
struct Foo<int> : Foo<int>
{
    virtual void F(int const&) const;
};

Wieso er nicht funktioniert ist mir klar.
Meine Frage:
Wie kann ich die das Verhalten der oben dargebotenen Situation auf eine andere Weise erzeugen? Ich möchte allerdings keine einfache Templatespezialisierung machen weil ich dann alle andere Member und Methoden bei jeder einzelnen Spezialisierung kopieren müsste. Die Implementierung der Funktion F ändert sich von Typ zu Typ, daher ist sie in der Basis rein virtuell.

Gruss

Verhalten der oben dargebotenen Situation auf eine andere Weise erzeugen

Ich sehe da kein Verhalten nur etwas hingerotzten Code. Was willst du machen?

template<class T>
class Rule
{
    std::string Raw;
public:
    /* Funktionen für die Behandlung des Strings, u.A. ihn aus istreams lesen */
    virtual bool operator() (T& Subject) const = 0;
};

Im String Raw ist eine in einer Skriptsprache von einer Datei ausgelesene Bedingung drin:

lenght<100;width<30;(width/lenght)<0.5;

Der Funktionsoperator gibt nun zurück ob der Parameter den er erhalten hat den Bedingungen im String gerecht wird und meldet das mit seinem Rückgabewert zurück. Da je nach zu prüfender Klasse unterschiedliche Member angesprochen werden, muss ich den Operator auch immer neu schreiben (der Teil der den String parsed ist natürlich nicht im Operator selbst).

template<>
struct Rule<Derived> : Rule<Derived> 
{
    virtual bool operator() (Derived& Subject) const
    {
        /* Die geparste Version des Strings mit Subject vergleichen */
        /* Und-Verknüpfung aller Resultate zurückgeben */
    }
};

Gruss.

template <>
struct derived : rule <derived>
{
  // ... usw usw ....
};

du meinst sicher CRTP

template <>
struct derived : rule <derived>
{
  // ... usw usw ....
};

Kannte ich nicht. Ich habe nun eine Basis für Rule gemacht und soweit funktioniert es. Danke.