How to assign const static with an incremental macro? - c++

Question

I am trying to assign an unique value to const static unsigned int members, without having to think about assigning the right values myself (preventing human errors). I've created a minimal solution for static unsigned int members, but I would really like to use const instead, because it's faster (and neat).
This is what I came up with:
// cat.h
#define ANIMAL_INDEX 0
#define GET_ANIMAL_INDEX (ANIMAL_INDEX (ANIMAL_INDEX + 1))
class Cat
{
protected:
Cat(){}
public:
const static unsigned int lynx = GET_ANIMAL_INDEX; // 0
const static unsigned int tiger = GET_ANIMAL_INDEX; // 1
};
This is just an example, but imagine that I would have like 1000 animals or something.
Is it possible to create a macro that increments every time it is used for assignment, or do I need to create a script which generates the cat.h?

Answer 1

If you're happy to move the definitions of your constants outside of their class, then a simple static function based implementation solves your problem:
class UniqueIndex
{
public:
static int getNext()
{
static int theIndex = 0;
return theIndex++;
}
};
class Cat
{
protected:
Cat(){}
public:
const static unsigned int lynx;
const static unsigned int tiger;
};
const unsigned int Cat::lynx = UniqueIndex::getNext();
const unsigned int Cat::tiger = UniqueIndex::getNext();
int main()
{
std::cout << Cat::lynx << ' ' << Cat::tiger << std::endl; //output: 0 1
return 0;
}

Answer 2

Disregarding how questionable a design this might be, an automatic counter can be useful in many cases, so here goes...
Add an abstraction around the "index" and let that handle the counting.
Then your members can be instances of this "indexing type" instead.
Something like this:
class Index
{
public:
Index() : idx(next()) {}
Index(const Index&) = delete;
Index& operator=(const Index&) = delete;
operator int () const { return idx; }
private:
const int idx;
// Avoid the "static initialization order fiasco".
static int next() { static int i = 0; return i++;}
};
struct A
{
const static Index idx;
};
const Index A::idx;
struct B
{
const static Index idx;
const static Index idx2;
};
const Index B::idx;
const Index B::idx2;
int main()
{
cout << A::idx << " " << B::idx << " " << B::idx2 << endl;
}