Design Problem

Schon Möglich. Du setzt aber Vererbung ein, was ja das eigentliche Verfahren ist, um Verhalten neu zu definieren. Die Absicht von Template-Spezialisierungen ist ja eher, das selbe Verhalten typabhängig (somit evtl. effizienter) zu implementieren.

Außerdem hat es mit den Spezialisierungen noch einen Nachteil: Wenn im Algorithmus sehr viele Methoden "austauschbar" sein sollen, hat man bei entsprechend vielen Typen sehr schnell hunderte Spezialisierungen.

Shade Of Mine

Verrücktwerd .. schrieb:

@Shade Of Mine: nee das meine ich nicht

Der Code der hier produziert wird sieht aber ziemlich danach aus.

Magst du mal beschreiben was du eigentlich machen willst? Und zwar abstrakt?

@Aquae:

genauso habe ich mir das vorgestellt.
der Algorithmus (bzw Schablone ist mein calc) und der Step2 ist typspezifisch anders, genauso wollte ich das, aber
bist du sicher das das so auch kompiliert?

template<typename T>
bool TypeSpecificBehaviour(T i)
{
  // ...
}

template<typename T>
int Algorithm(T p1, T p2, TypeSpecificBehaviour<T> step2)
{
  // ...
  step2();
  // ...
}

Ich glaube Shade Of Mine meint so etwas. Hat natürlich den Vorteil, dass du die typspezifischen Funktionen mischen kannst und sie nicht fest in abgeleitete Klassen verdrahtest.

@Shade Of Mine:

Ich möchte einen Algorithmus entwerfen der abhängig vom Typ, innerhalb ein teilweise anderes Verhalten aufweist. Weiterhin sollen eben andere Typen diesen Algorithmus verwenden können, dadurch, dass diese Verhalten implmenetiert wird.

Shade Of Mine

Verrücktwerd .. schrieb:

Ich möchte einen Algorithmus entwerfen der abhängig vom Typ, innerhalb ein teilweise anderes Verhalten aufweist. Weiterhin sollen eben andere Typen diesen Algorithmus verwenden können, dadurch, dass diese Verhalten implmenetiert wird.

std::sort erfüllt genau diese anforderungen.

ich kann sort für alle typen und container aufrufen die die minimalen anforderungen erfüllen (sprich: das minimal notwendige verhalten implementieren)

Multiple markers at this line
- in diesem Zusammenhang
- Variable »a« kann nicht als vom abstrakten Typ »AlgoInt« deklariert werden

ist meine Fehlermeldung, was mach ich noch falsch?

Mfg

.. erhalte ich bei der Implmentierung dieser Variante:

template <typename T>
class Algo
{
    public:

        void calc()
        {
            Step1();
            Step2(T());
            Step3();
        }

    protected:
        virtual ~Algo(){}

        virtual void Step2(T)=0;

    private:
        void Step1() {std::cout << "Step1" << std::endl;}
        void Step3() {std::cout << "Step3" << std::endl;}
};

class AlgoInt : public Algo<int>
{
    virtual void Step2(int)
    {
        std::cout << "Step2 - int" << std::endl;
    }
};

int main()
{
    AlgoInt a;

    a.calc();

}

.. obige Fehlermeldung erhalte ich, wenn ich ein Objekt vom Typ AlgoInt in einer anderen Klasse (Header included) deklariere und auf diesem Objekt die Methode calc aufrufe.

hustbaer

Versuch das mal mit einem anderen Compiler, z.B. dem Comeau Online.

g++ 4.3.0 schluckt das ohne Probleme. Wie benutzt du es denn?

ich habe jetzt

algo.h:
template <typename T>
class Algo
{
    public:

        void calc()
        {
            Step2(T());   
        }

    protected:
        virtual ~Algo(){}

        virtual void Step2(T)=0;
}

algoint.h:
class AlgoInt : public Algo<int>
{
    virtual void Step2(int);
};

algoint.cpp:
class AlgoInt : public Algo<int>
{
    virtual void Step2(int);
    {
        std::cout << "Step2 - int" << std::endl;
    }
};

test.cpp:
AlgoInt a;

    a.calc();

Braunstein

Wozu soll jetzt diese algoint.cpp gut sein?
Packe den gesamten Code in die algoint.h, dann soltte es auch gehen.

und als Fehlermeldung:

zu:

Step2(T());

Elementfunktion kann nicht ohne Objekt aufgerufen werden

zu test.cpp:

Variable »a« kann nicht als vom abstrakten Typ »AgloInt« deklariert werden

@Braunstein:

naja ich implmentiere halt noch einige weitere Funktionen und möchte da eine saubere Trennung.

Nein, das spielt kein Rolle.

algoint.cpp:
class AlgoInt : public Algo<int>
{
    virtual void Step2(int); // <- Deshalb ist die abstrakte Methode nicht definiert
    {
        std::cout << "Step2 - int" << std::endl;
    }
};

das ist bei mir nicht drin, das Komma!
... das kann es also nicht sein!

Verrücktwerd .. schrieb:

algoint.cpp:
class AlgoInt : public Algo<int>
{
    virtual void Step2(int);
    {
        std::cout << "Step2 - int" << std::endl;
    }
};

ja das war ein copy & paste Fehler.

Bei der Klasse AgloInt zeigt er mir noch den Fehler:

denn die folgenden virtuellen Funktionen sind rein innerhalb »AgloInt«:

ach hoppla, den code vorhin muss ich ja mit zwei geschlossenen augen angesehen haben. da ist ziemlich vieles falsch!