Inheritance from Template Class

Question

I am trying to implement a FSM class and for making it more generic, I decided to use template classes; however, I am receiving some errors. The errors are not very clear (thanks to Xcode), but I think the problem is the way how I am declaring my classes and handling the inheritance, etc.

UPDATE:

Errors:

Here's my code:

FiniteStateMachine.hpp

---------------------------------
template<class RETURNS, typename PARAMS>
class BaseState
{
public:
    // For forcing all the classes have this method
    virtual std::vector<RETURNS> performDecision(PARAMS& pList) = 0;
};

template<class R, typename P>
class FSM_State : public BaseState<R, P>
{
public:

    FSM_State(int pStateNum = 0);
    virtual ~FSM_State();

    void init(int pStateNum = 0);

    void addState(FSM_State<R,P>* pState);
    void addState(const int pIndex, FSM_State<R,P>* pState);

    virtual std::vector<R> performDecision(P& pList) = 0;

protected:

    std::vector<FSM_State*> mStateList;
};


OHB_DT_FSM.hpp

-----------------------------------------

class OHB_DT_FSM_State : public FSM_State<eDECISION_TYPES, GameAI>
{
public:

    OHB_DT_FSM_State(int pStateNum = 0)
        : FSM_State(pStateNum)
    {}

    virtual ~OHB_DT_FSM_State()
    {
        delete mDecisionTree;
    }

    virtual void constructDT() = 0;

    virtual std::vector<eDECISION_TYPES> performDecision(GameAI& pList) = 0;

protected:

    eSTATE_TYPES mType;

    std::vector<eDECISION_TYPES> mDecisionList;

    DecisionTree* mDecisionTree;
};

This is how I am handling the inheritance, but since I am not experienced about templates, I am not sure about my approach.

For every method that is not described in .hpp file, I have the codes in .cpp files.

CPP File:

template<class R, typename P>
FSM_State<R, P>::FSM_State(int pStateNum)
{
    init(pStateNum);
}

template<class R, typename P>
FSM_State<R, P>::~FSM_State()
{
    for(int si = 0; si < mStateList.size(); si++)
    {
        delete mStateList[si];
    }

    mStateList.clear();
}

template<class R, typename P>
void FSM_State<R, P>::init(int pStateNum)
{
    if(pStateNum > 0)
    {
        mStateList.resize(pStateNum);
    }
}

template<class R, typename P>
void FSM_State<R, P>::addState(FSM_State* pState)
{
    mStateList.push_back(pState);
}

template<class R, typename P>
void FSM_State<R, P>::addState(const int pIndex, FSM_State* pState)
{
    mStateList[pIndex] = pState;
}

Thank you!

You're going to want to revisit defining the function is a cpp file: https://stackoverflow.com/questions/495021/why-can-templates-only-be-implemented-in-the-header-file — NathanOliver, Aug 10 '17 at 14:22
what are the errors? They may be not clear to you, but maybe to others — 463035818_is_not_an_ai, Aug 10 '17 at 14:22
Function definitions seem correct, cpp file and error codes are added @NathanOliver — ciyo, Aug 11 '17 at 07:23

score 0 · Answer 1 · answered Aug 14 '17 at 03:26

Nothing in the CPP file where class FSM_state is defined triggers an instantiation of FSM_state<eDECISION_TYPES, GameAI> - the compiler has no reason to build one, so it doesn't. Then when the compiler gets to that very instantiation in OHB_DT_FSM.hpp - presumably in a different compilation unit - it no longer has access to the class definition, so it can't build that instantiation.

As other commentators have noted - one solution to this problem is to include the definition (not just the declaration) of your template class everywhere it is used - usually by putting the definition in the header. This has its advantages and disadvantages - any change to the internals of FSM_state now means that everything that depends on it has to be recompiled.

Another option is to add to your CPP file where FSM_state is defined an explicit instantiation of the type you know you will need:

template class FSM_state<eDECISION_TYPES, GameAI>;

This essentially gives the compiler the hint to instantiate the template class for those parameters, even though nothing else in the compilation unit needs that particular instantiation.

Freakyy · Answer 2 · 2017-08-10T14:32:23.917

-2

When declaring a virtual function, consider the part at the end:

= 0; indicates a Pure-Virtual Function which means that this function has to be implemented by a deriving class
override; means that you are overriding a virtual function from a base class

In your example, you only use = 0; - but both FSM_State and OHB_DT_FSM_State should override your performDecision here.

edited Aug 10 '17 at 14:32

answered Aug 10 '17 at 14:27

Freakyy

365
5
16

how do you know that this is the problem? The code as OP shows here does not attempt to instantiate objects of those classes. Maybe they are meant to be abstract – 463035818_is_not_an_ai Aug 10 '17 at 14:32
You're right, I assumed. I just figured since OP didn't provide other code. – Freakyy Aug 10 '17 at 14:35
It says "// For forcing all the classes have this method" at the very beginning of the code. – ciyo Aug 11 '17 at 07:23
Okay, so you don't want ```FSM_State``` to implement this method? – Freakyy Aug 11 '17 at 07:28

Inheritance from Template Class

2 Answers2