在模板类中初始化静态指针

Question

考虑这样一个类：

template < class T >
class MyClass
{
  private:
    static T staticObject;
    static T * staticPointerObject;
};
...
template < class T >
T MyClass<T>::staticObject; // <-- works
...
template < class T >
T * MyClass<T>::staticPointerObject = NULL; // <-- cannot find symbol staticPointerObject.

我无法弄清楚为什么我无法成功创建该指针对象。

上面的代码都是在头文件中指定的，我提到的问题是链接步骤中的错误，所以它没有找到特定的符号。

Answer 1

“无法找到符号 staticPointerObject” - 这看起来像链接器错误消息。是吗？ （必须在您的问题中指定此类详细信息）。

如果是，则很可能会发生这种情况，因为您将静态成员的定义放入实现文件（.cpp 文件）中。为了使其正常工作，定义应放入头文件（.h 文件）中。

同样，必须在您的问题中指定此类详细信息。没有他们，它就会变成一场随机的猜测盛宴。

Answer 2

我怀疑您的第一个示例的原因如下（来自 2003 C++ std 文档）。特别注意最后一句——从你的例子来看，似乎没有什么“需要成员定义存在”。

14.7.1 隐式实例化 [temp.inst] 1 除非类模板特化已显式实例化 (14.7.2) 或显式实例化
专门化（14.7.3），类模板专门化是隐式的
当在上下文中引用专业化时实例化
需要一个完全定义的对象类型或者当
类类型影响程序的语义。隐含的
类模板专门化的实例化会导致隐式
声明的实例化，但不是定义或的实例化
类成员函数、成员类的默认参数，
静态数据成员和成员模板；它会导致隐含的
成员匿名联合定义的实例化。除非一个
类模板或成员模板的成员已显式
实例化或显式专门化，
当专业化为成员时，成员被隐式实例化
在需要成员定义存在的上下文中引用；
特别是，初始化（以及任何相关的副作用）
静态数据成员不会出现，除非静态数据成员是
本身的使用方式需要静态数据的定义
成员存在。

Answer 3

您对静态成员的第一个“定义”只是一个声明 - 这是标准的引用。

15 的显式专业化
模板的静态数据成员是
定义（如果声明包含）
初始化器；否则，它是一个
宣言。 [注意：没有语法
静态数据的定义
需要的模板成员
默认初始化。模板>> X
问：：x；这是一份声明
不管X是否可以默认
初始化（8.5）。 ]

第二个定义应该有效。您确定在一个编译单元中拥有所有可用的内容吗？错误消息的确切文本是什么？

以下内容使用 g++ 编译/运行 - 全部在一个文件中

#include <iostream>

template < class T >
class MyClass
{
  public:
    static T staticObject;
    static T * staticPointerObject;
};

template < class T >
T MyClass<T>::staticObject;

template < class T >
T * MyClass<T>::staticPointerObject = 0; 

int main(int argc, char **argv)
{
  int an_int = 5;
  MyClass<int>::staticPointerObject = &an_int;
  std::cout << *MyClass<int>::staticPointerObject << std::endl;

  char a_char = 'a';
  MyClass<char>::staticPointerObject = &a_char;
  std::cout << *MyClass<char>::staticPointerObject << std::endl;
}

Answer 4

我找到了两种解决方案。他们都不是100%我所希望的。

1. 显式初始化特定实例，例如

   int * MyClass::staticPointerObject = NULL;

这并不方便，尤其是当我有很多不同的类型时。

2. 将指针包装在类内部，例如，

    template < class T >   
    class MyClass   
    {   
      private:   
        struct PointerWrapper   
        {   
          T * pointer;   
          PointerWrapper( void )   
            : pointer( NULL )   
          { }   
        };   
        T staticObject;   
        PointerWrapper staticPointerObject;   
    };   
    ...   
    template < class T >   
    T MyClass<T>::staticObject; // <-- works fine.   
    ...   
    template < class T >   
    MyClass<T>::PointerWrapper MyClass<T>::staticPointerObject; // <-- works fine.

这有点麻烦，但至少可用。为什么我可以实例化变量对象但不能实例化指向变量对象的指针？如果有的话，我认为反过来我会遇到更多问题（编译器提前知道指针是什么样子，但不知道我的对象是什么样子）。

如果有人有更好的答案，我很乐意看到！

Answer 5

我一直使用以下技巧。这个想法是将静态放在一个函数中，并且仅从该函数访问它。这种方法还允许您避免在 .cpp 文件中声明静态的需要——所有内容都可以存在于 .h 文件中。按照您的示例代码：

template < class T >
class MyClass
{
  public:
    static T * getObject() {
      // Initialization goes here.
      static T * object = NULL; // or whatever you want
      return pointerObject;
    }
};