Design Problem

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.

@Aquae: ja aber genau so habe ich es!

Braunstein

Wirklich?
Dein Code vorhin sah aber nicht so aus.

das ist jetzt mal der code wie ich ihn verwende:

algo.h
template< typename input, typename list, typename output>
class Algo
{
public:
  /* Constructor */
  Algo();

  static void calc( input &in, list &lis, output &out)
  {
    ...
    Step2( input(), matrix(), output());
    ... 
    Step3( m, list(), output())
    ...
}

protected:
  /* Destructor */
  virtual ~Algo();

  virtual void Step2( input, list, output)=0;

  virtual void Step3( int &m, list, output)=0;

private:

};

algoInt.h:
class AggloClusterMeasurement3D : public AlgoInt< int, int, int>
{
public:
  /* Constructor */
  AlgoInt();
  /* Destructor */
  virtual ~AlgoInt();

private:
  virtual void Step2( input, list, output);

  virtual void Step3( int &m, list, output);
};

algoint.cpp:

void Step2( input, list, output)
{
  ..
}

void Step3( int &m, list, output)
{
  ..
}

sodele

warum funktioniert das jetzt nicht ??

Verrücktwerd .. schrieb:

@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.

Steht der Typ schon zur Compilezeit oder erst zur Laufzeit fest?