virtual data type/enum

Question

Hello,

I want a virtual class like this:

class Configuration 
{
public:
    enum EPromptId;

    virtual CString getPrompt( EPromptId promptId ) = 0;
private:
};

So that each derived configuration can have its own set of EPromptIds

 class Configuration1 : public Configuration
{
public:
    enum EPromptId{
        epid_HappyBirthday
    };

    CString getPrompt( EPromptId promptId ){
        return "";
    }
private:
};

class Configuration2 : public Configuration
{
public:
    enum EPromptId{
        epid_JummpingJehoshaphat
    };

    CString getPrompt( EPromptId promptId ){
        return "";
    }
private:
};

This fails as each class needs to implment a virtual function with a Configuration::EPromptId parameter (not a Configuration1::EPromptId or Configuration2::EPromptId as in this code).

Is it possible to get the base class to recognise the parameter type but define the values differently in each derived class (perhaps not using enums, but keeping it strongly typed, i.e. not using an int).

EDIT : I want two different configurations for two different 'applications'. The prompts could be held in a db table but each 'application' will have it's own table. A pointer to the base configuration class is contained in a class which interfaces to some hardware (i.e. which does the actual displaying). The hardware is an io device that can be used to request and receive user input. When the hardware class is created it will be passed a pointer to the correct configuration class and so display the right prompts when requested.

Answer 1

First: You want an abstract class. (An abstract class is one that has at least one pure virtual function. A virtual base class is a class that's virtual derived from.)

Then: No, what you want is not possible. You cannot forward-declare an enum and define it later, let alone define it differently. And even if you could: what would happen if someone passes epid_HappyBirthday to Configuration2 which doesn't know about it?

I suggest you explain to us what you want to do (instead of whether the way you thought you found how to do this works) and maybe someone can come up with an idiom to solve your problem.

Answer 2

You can't mix compile-time type checking with runtime virtual function resolving.

You can have generic

class Configuration 
{
public:
    virtual CString getPrompt( int promptId ) = 0;
private:
};

and define two member functions in derivatives:

class Configuration1 : public Configuration
{
public:
    enum EPromptId{
        epid_HappyBirthday
    };

    CString getConfiguration1Prompt( EPromptId promptId ){
        return "";
    }
    virtual CString getPrompt( int promptId )
    {
      return getConfiguration1Prompt(static_cast<EPromptId>(promptId));
    } 
private:
};

class Configuration2 : public Configuration
{
public:
    enum EPromptId{
        epid_JummpingJehoshaphat
    };

    CString getConfiguration2Prompt( EPromptId promptId ){
        return "";
    }
    virtual CString getPrompt( int promptId )
    {
      return getConfiguration2Prompt(static_cast<EPromptId>(promptId));
    } 
private:
};

If you want to ensure valid promptId you should check it manually in runtime in child classes.

Anyway this approach is not useful because to use generic getPrompt() function you'll need to know which child class you're using to get access to its EPromptId.

Answer 3

My c++ is a bit rusty but can't you do something like

struct EPromptId {
    EPromptId() mId(sId++) { }
    operator int() { return mId; }
    friend static bool operator==(EPromptId lhs, EPromptId rhs) { 
        return lhs.mId == rhs.mId;
    }
private:
    int mId;
    static int sId;
};

struct configuration1 {
    static const EPromptId epid_HappyBirthday;
    static const EPromptId epid_xxx;

    CString getPrompt(EPromptId promptId ){
        if (promptId == epid_HappyBirthday)
            return "";
        else if (promptId == epid_xxx)
    }
}

// somewhere else
EPromptId configuration1::epid_HappyBirthday;
EPromptId configuration1::epid_xxx;

If you want to control each id manually, just add a and int constructor
EPromptId(int id) mId(id) { }

and change the initialization to

EPromptId configuration1::epid_HappyBirthday = 1;
EPromptId configuration1::epid_xxx = 5;

Answer 4

You might be able to get most of what you want with templates... as long as you weren't hoping to keep around an collection of Configuration* and access them that way (you weren't, were you? Because you'd need to know their types to know what to pass anyway....)

template< typename ENUM_TYPE >
class Configuration 
{
public:
    virtual CString getPrompt( ENUM_TYPE promptId ) = 0;
private:
};

then

enum EPromptId{
    epid_HappyBirthday
};

class Configuration1 : public Configuration< EPromptId >
{
public:
    CString getPrompt( EPromptId promptId ){
        return "";
    }
private:
};