Design Problem

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!

ahha und was sonst noch?

Irgendwie hab ich den Eindruck, du kommst mit der Trennung Header/Source nicht zurecht...

//algoInt.h
#include "Algo.h"

class AlgoInt : public Algo<int>
{
    virtual void Step2(int); // <- Deklaration
};

//algoInt.cpp
#include "algoInt.h"

void AlgoInt::Step2(int) //<- Definition
{
	 std::cout << "Step2 - int" << std::endl;
}

Fehlendes Semikolon, Redefinition von AlgoInt. Ansonsten sollte der Code wohl kompilieren.