在C ++中，是否可以在构造函数中访问静态变量？

Question

我在尝试：

class MyClass {
public:
    MyClass();

    int myID;
    static int currentID;
};

MyClass::MyClass() {
    myID = currentID;
    ++currentID;
}

我正在尝试为此类的所有实例分配一个唯一的ID。

编辑：

它对我不起作用。 我在xcode中得到了两个：

未定义的符号：“GameObject :: currentID”，引用自：GameObject.o中的__ZN10GameObject9currentIDE $ non_lazy_ptr（也许你的意思是：__ ZN10GameObject9currentIDE $ non_lazy_ptr）ld：未找到符号collect2：ld返回1退出状态

Answer 1

这个对我有用：

#include <iostream>

class My
{
    public:
    My() : id(++currentId) {}

    int id;
    static int currentId;
};

int My::currentId = 0;

std::ostream & operator<<(std::ostream & os, My & m)
{
    return os << m.id;
}

int main()
{
    My a;
    My b;
    My c;

    std::cout << a << std::endl;
    std::cout << b << std::endl;
    std::cout << c << std::endl;
}

输出：

> ./x
1
2
3

Answer 2

除了其他情况，它适用于以下情况：

MyClass a[10];
MyClass* b = new MyClass[10];

如果使用STL容器来保存MyClass对象，请小心。 它可能与您预期的行为不一样，并且很难找到问题。 请参阅以下示例：

int MyClass::currentID = 0;
...
std::vector<MyClass> c(10);
MyClass a;

在这种情况下，结果如下：

c[0].myID = 0;
c[1].myID = 0;
....
c[9].myID = 0
=============
   a.myID = 1. 

默认构造函数只执行一次。 原因是std :: vector的构造函数将使用相同的值来初始化向量的所有元素。 在我的系统中，std :: vector的构造函数如下：

  explicit
  vector(size_type __n, const value_type& __value = value_type(),
     const allocator_type& __a = allocator_type())
  : _Base(__n, __a)
  { _M_fill_initialize(__n, __value); }   

_M_fill_initialize将初始化使用__value （来自默认构造函数value_type() ） __n次分配的内存。

上面的代码最终将调用uninitialized_fill_n ，它执行以下操作：

for (; __n > 0; --__n, ++__cur)
    std::_Construct(&*__cur, __x);

这是std::_Contruct ：

template<typename _T1, typename _T2>
inline void
_Construct(_T1* __p, const _T2& __value)
{
  // _GLIBCXX_RESOLVE_LIB_DEFECTS
  // 402. wrong new expression in [some_]allocator::construct
  ::new(static_cast<void*>(__p)) _T1(__value);
}

在这里，您可以看到它最终调用全局运算符new来使用相同的值初始化向量中的每个元素。

结论是， 使用静态成员到初始数据成员将在大多数情况下工作，但如果您计划在STL容器中使用它，它可能会失败，并且很难找到问题。 我只尝试过std::vector ，当使用其他类型的stl容器与MyClass对象时，很可能存在问题。

Answer 3

你得到错误的原因不是因为你从构造函数访问静态，这是合法的btw，但是因为你没有定义它。

class My
{
    public:
    My() : id(++currentId) {}

    int id;
    static int currentId;
};

//place the definition in the implementation file
int My::currentId = 0;

Answer 4

您需要确保在类外定义和初始化类的静态成员。 这对我有用：

#include <iostream>
class MyClass {
private:
    int myID;
    static int currentID;
public:
   //default constructor
    MyClass()
        : myID(currentID) 
        {
            ++currentID;
        }

    void printId() { std::cout << "Object Id :" << myID << std::endl; } /*Prints the unique ID assigned to each object.*/
};

// define the static class member here:
int MyClass::currentID = 1;

int main()
{
    MyClass m1, m2, m3;
    m1.printId();
    m2.printId();
    m3.printId();
}

输出：

对象ID：1

对象ID：2

对象ID：3

Answer 5

是没关系，只要你没有MyClass的静态实例。

Answer 6

好的，可以。 但是你编写的代码不是线程安全的：可以在不同的线程中同时实例化2个类。 在第一个实例有时间增加静态变量之前，第二个实例可以获取相同的currentID值。

这对您来说可能是也可能不是问题。

如果您需要线程安全， 这个问题应该有所帮助。

Answer 7

int MyClass::currentID=0;  

如果没有完成，您需要在CPP文件中执行此操作