Question

我希望有一个带有静态数据成员的模板化类，并通过模拟一个＆＃34;静态构造函数来初始化它。＆＃34;对于非模板类，已经回答了这个问题（请参阅static constructors in C++? I need to initialize private static objects和What is a static constructor?）。但是，没有一个答案似乎适用于模板化的课程。

以下是尝试调整＆＃34;静态构造函数＆＃34;的示例。来自之前对模板类的回答的成语。（请注意，该示例只是初始化int，并且可以在没有此类构造函数的情况下编写;但是，我需要一般解决方案。）

#include <iostream>

struct Foo
{
    static int x;
    static struct init
    {
        init()
        {
            std::cout << "Initializing Foo..." << std::endl;
            x = 1;
        }
    } initializer;
};
int Foo::x;
Foo::init Foo::initializer;

template<int N>
struct Bar
{
    static int x;
    static struct init
    {
        init()
        {
            std::cout << "Initializing Bar..." << std::endl;
            x = N;
        }
    } initializer;
};

template<int N>
int Bar<N>::x;
template<int N>
typename Bar<N>::init Bar<N>::initializer;

int main()
{
    std::cout << Foo::x << std::endl;
    std::cout << Bar<1>::x << std::endl;
    return 0;
}

输出：

Initializing Foo...
1
0

但我希望它输出：

Initializing Foo...
Initializing Bar...
1
1

这是＆＃34;静态初始化顺序惨败的一个例子吗？＆＃34;

Answer 1

不，它是不是静态初始化命令惨败。这只是因为模板类的每个成员都是自己的模板，因此在使用之前不会实例化。

您的代码从不使用init成员，因此init永远不会被实例化。

但是，您的问题很容易解决：

#include <iostream>

template<int N>
struct Bar 
{
    static int x;
};

template<int N>
int Bar<N>::x= N;

int main()
{
    std::cout << Bar<1>::x << std::endl;
    return 0;
}

这样可以更简单的方式为您提供所需的内容。

Answer 2

您需要明确地实例化initializer：

[...]
template<int N>
typename Bar<N>::init Bar<N>::initializer;

template
typename Bar<1>::init Bar<1>::initializer;

int main()
{
    std::cout << Foo::x << std::endl;
    std::cout << Bar<1>::x << std::endl;
    return 0;
}

原因是Bar<1>::x不依赖于Bar<1>::initializer。因此，编译器不会实例化它，因为您不使用它。 Actualy，initializer初始化不会初始化x。 x首先零初始化，然后如果initializer被实例化，则x 分配新值。

只要initializer在x 实例化的同一翻译单元中实例化，就不存在静态初始化失败的风险。因此，明确地实例化x肯定是一个好主意。

或者，您可以将这些变量声明为静态本地：

#include <iostream>
template<int N>
struct Bar
{
    static int x()
      {
      static int x_val;
      static struct init
        {
        init()
          {
          std::cout << "Initializing Bar..." << std::endl;
          x_val = N;
          }
        } initializer;//indeed this circumvolution is no more needed.
      return x_val;
      }
};
int main(){
    std::cout << Bar<1>::x() << std::endl;
}

但是如果初始化不是很简单，那么x()中生成的代码可能会进行优化。

根据您的问题，您还可以将x定义为int：

的包装器

class int_inited{
  int val;
  public:
  int_inited(){
    std::cout << "Perfoming initialization" << std::endl;
    val=42;
    }
  operator int&(){
    return val;
    }
  operator const int &() const{
    return val;
    }
  };

template<class N>
struct Bar{
  static int_inited x;
  [...];

Answer 3

我找到了适用于任何数据类型的干净解决方案。由于当编译器遇到要实例化的特定template时，会评估Bar<N>::x内的赋值操作，我们可以写：

template<int N>
int Bar<N>::x = init<N>();

其中init()是N上模板化的函数，返回int。此外，init()仅对编译器实例化的N的每个值调用一次。

作为一个更有用的例子，我在这里根据一些任意函数初始化静态std::array：

#include <iostream>
#include <array>

template<int N>
struct Foo
{
    static std::array<double,N> x;
};

template<int N>
std::array<double,N> init()
{
    std::array<double,N> y;
    for (int i=0; i<N; ++i) {
        y[i] = (double)(i*i+i)/N;
    }
    return y;
}

template<int N>
std::array<double,N> Foo<N>::x = init<N>();

int main()
{
    const int N = 10;
    for (int i=0; i<N; ++i) {
        std::cout << Foo<N>::x[i] << std::endl;
    }
    return 0;
}

模拟模板类的静态构造函数

3 个答案: