Question

我正在尝试为const static unsigned int成员分配一个唯一值，而不必考虑自己分配正确的值（防止人为错误）。我为static unsigned int成员创建了一个最小解决方案，但我真的想使用const代替，因为它更快（而且更整洁）。

这就是我提出的：

// 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
};

这只是一个例子，但想象一下我会喜欢1000只动物。

是否可以创建一个每次用于赋值时递增的宏，或者我是否需要创建一个生成cat.h的脚本？

Answer 1

如果您乐意将常量的定义移到其类之外，那么基于静态函数的简单实现可以解决您的问题：

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

无论设计有多可疑，自动计数器在许多情况下都很有用，所以这里有......

在＆＃34;索引＆＃34;周围添加一个抽象。并让它处理计数那么你的成员就可以成为这个＆＃34;索引类型＆＃34;的实例。代替。

这样的事情：

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;
}

如何使用增量宏分配const static？

2 个答案: