Question

I am trying to write a base class, and a set of N derived classes, where each each derived class has its own unique identifier, here is a simple, ‘manual’ implementation:

struct Base {
    static int id_ = 0;
};

struct Derived1 : public Base {
    static int id_ = 1;
};

struct Derived2 : public Base {
    static int id_ = 2;
};

The problem is, if I want to continue adding derived classes, I must count the number of already existing derived classes.

Things also get more complicated, because I want to use a bitset to represent the unique ID. If every derived class’s unique ID is basically just a different bit (of a common-length bitset) set to 1, it makes it very easy to perform binary AND/OR/XOR/etc operations on groups of derived classes.

The following is a incomplete and incorrect implementation of what I want

//Let DCOUNT be the number of derived classes, Ideally I shouldnt have to ever
//know/think about what it evaluates too, it should be automatic.
//But that is second priority, I would be willing to #define this to 
//some 'large' value, and not worry about it.
struct Base {
    static std::bitset<DCOUNT> id_ = generateUniqueID(); // "00000"
};

struct Derived1 {
    static std::bitset<DCOUNT> id_ = generateUniqueID(); // "00001"
};

struct Derived2 {
    static std::bitset<DCOUNT> id_ = generateUniqueID(); // "00010"
};

What is the best way to implement this? (or something like it)

Answer 1

What about something simple like a family of functions (template) that generates and keeps an id for each type, like this:

 template<typename T>
 static std::bitset<DCOUNT> getId()
 {
     static std::bitset<DCOUNT> bitset;
     static bool bitsetCreated = false;
     if ( false == bitsetCreated )
     {
        bitset = generateUniqueID();
        bitsetCreated = true;
     }
     return bitset;
 }

Afterwards you can get the IDs like this: getId < YourType > ();
They are generated at runtime, so no problem with generateUniqueID();