Marco Nef a écrit :

Hi there,

I'm trying to do something like the following:

template<class TYPE> class CFlags
{
public:
VOID AddFlag(TYPE eFlag);
VOID RemoveFlag(TYPE eFlag);
};

class CClass1 : public CFlags<CClass1::EFlags>
{
public:
typedef enum EFlags
{
...
} EFlags;
};

class CClass2 : public CClass1,public CFlags<CClass2::EFlags>
{
public:
typedef enum EFlags
{
...
} EFlags;
};

I know that this cannot work because the EFlags are not known where
needed. I've tried many things, but none was a nice solution or worked
at all (I prefer a real C++ solution, which means there should be no
macros).

Does anyone have an idea how to solve the following problems in a nice
C++ way?

- EFlags should not be in global space
- Each class in a hierarchy may have its own flags
- The flags must be type specific

If having only one kind of flags is acceptable, a simple CRTP solution is:

[garbage]

Marco Nef a écrit :

Hi there,

I'm trying to do something like the following:

template<class TYPE> class CFlags
{
public:
VOID AddFlag(TYPE eFlag);
VOID RemoveFlag(TYPE eFlag);
};

class CClass1 : public CFlags<CClass1::EFlags>
{
public:
typedef enum EFlags
{
...
} EFlags;
};

class CClass2 : public CClass1,public CFlags<CClass2::EFlags>
{
public:
typedef enum EFlags
{
...
} EFlags;
};

I know that this cannot work because the EFlags are not known where
needed. I've tried many things, but none was a nice solution or worked at
all (I prefer a real C++ solution, which means there should be no
macros).

Does anyone have an idea how to solve the following problems in a nice
C++ way?

- EFlags should not be in global space
- Each class in a hierarchy may have its own flags
- The flags must be type specific

Since "EFlags should not be in global space", that means you cannot use it
directly in CFlags<> instance (i.e. in member or in function parameters),
only in called function. As a consequence, the derived class must also
handle the storage of the flags storage.

The closer solution I could think of is the following:
template<class T_CRTP> class CFlags
{
public:
template<TYPE>
void AddFlag(TYPE eFlag)
{
TYPE current;
static_cast<T_CRTP>(this)->get_flags(current);
//operations
static_cast<T_CRTP*>(this)->set_flags(current);
}
template<TYPE>
void RemoveFlag(TYPE eFlag)
{
TYPE current;
static_cast<T_CRTP*>(this)->get_flags(current);
//operations
static_cast<T_CRTP*>(this)->set_flags(current);
}
};

And

class CClass1 : public CFlags<CClass1>
{
public:
enum EFlags1
{
flagA
...
};
void get_flags(EFlags1& flags);
void set_flags(EFlags1& flags);

enum EFlags2
{
flagB
...
};
void get_flags(EFlags2& flags);
void set_flags(EFlags2& flags);
};


CClass1 c1:
//Calls CFlags<CClass1>::AddFlag<CClass1::EFlags1>(CClass1::EFlags1)
c1.AddFlag(CClass1::flagA);
//Calls CFlags<CClass1>::AddFlag<CClass1::EFlags2>(CClass1::EFlags2)
c1.AddFlag(CClass1::flagB);


Michael