需要以编程方式初始化类变量数组，如何才能最好地完成？ 在C++中，我有一个双子座数组，需要在程序中初始化，在运行时，只需要一次，以便整个类共享。它们可以是静态的，也可以是恒定的。我怎样才能最好地初始化它们？随着并行处理器的普及，我已经不再使用静态处理器了。所以我必须设置一个运行一次的标志，或者是否有一些静态常量魔法将它们初始化为函数（ok）或类（也ok）的局部变量

_编辑 不幸的是，当涉及到我的代码时

    static const int MIDTRACE = 3;
    static const int NUMTRACES = 2 * MIDTRACE + 1;
    static double WEIGHTATI[NUMTRACES];

我收到链接器错误：

meobj.obj:错误LNK2020:未解析令牌（0A00001C）“私有：静态双精度*mens:meclass:：PIMPL:：WEIGHTATI”（？WEIGHTATI@PIMPL@meclass@mens@@$$Q0PANA） meobj.obj:错误LNK2001:未解析的外部符号“private:static double*mens:meclass:：PIMPL:：WEIGHTATI”（？WEIGHTATI@PIMPL@meclass@mens@@$$Q0PANA）

由于我的构造师：

meclass::PIMPL() {
    if (!doneStaticInit) {
        double sumOfWeights = 0.0;
        for (int i = 0; i < NUMTRACES; i++) {
            WEIGHTATI[i] = SQUARED(1 - SQUARED(MAXTRACEWRTMIDTRACE * (MIDTRACE - i) / double(MIDTRACE)));
            sumOfWeights += WEIGHTATI[i];
        }
        for (int i = 0; i < NUMTRACES; i++) WEIGHTATI[i] /= sumOfWeights;
        doneStaticInit = true;
    }
}

meclass:：PIMPL（）{
如果（！donestaticint）{
双倍重量总和=0.0；
对于（int i=0；i

初始化=>构造函数。Once=>静态实例。一种方法是使用构造函数的静态实例

#include <iostream>

struct Foo
{
    Foo()
    {
        std::cout << "Initializing them values..." << std::endl;
        for( int i = 0;  i < 3;  ++i )
        {
            values[i] = i;
        }
    };

    int values[3];
};

void doThings()
{
    static Foo const    foo;        // Is initialized ONCE.

    for( int i = 0;  i < 3;  ++i )
    {
        std::cout << foo.values[i] << " ";
    }
    std::cout << std::endl;
}

int main()
{
    doThings();
    doThings();
    doThings();
}

#包括
结构Foo
{
Foo（）
{
std:：cout您可以在构造函数中放置一个
静态bool
标志。该标志只会在第一次调用时初始化为
false
。之后它将保持为true

// foo.h

class Foo {
  static const int MIDTRACE = 3; // static const, no definition needed
  static const int NUMTRACES = 2 * MIDTRACE + 1; // static const, no definition needed
  static double WEIGHTATI[NUMTRACES]; // not const, so need definition outside of class
public:
  Foo() {
    static bool array_initialized = false;
    if( !array_initialized ) {
      // Initialize array
      array_initialized = true;
    }
  }
  // Other members
};

在源文件而不是头文件中：

// foo.cpp
include "foo.h"
double Foo::WEIGHTATI[NUMTRACES];

似乎是显式的，而不是编程初始化的。+1对于目前流行的并行处理器来说非常流行。当前流行的并行处理器非常流行？！请告诉我你是故意写的！这几乎就是我编辑的内容，如果网站不拒绝的话，uuuuuu编辑uuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuu这就是构造函数的作用：）只是希望解决我的静态、常量和初始化问题。在构造函数中这样做的目的是在每次实例化时重新初始化它。此外，您还没有将您的/我的数组声明为静态数组，因此您的解释是“Once=>static instance”is，IMHO，left Waging。抱歉，如果你认为我想要一个静态使用的类，我必须让它更清楚。@John:我更改了代码以使它更清晰。在原始代码和当前代码中，
foo
都是静态、常量和初始化一次。但是如果你运行这个新代码，你可以看到它只初始化了一次。@John:你的第一句话是错。你的第二句是错的。你的第三句，我不明白，我认为它没有意义。这个cpp文件刚刚被PIMPL处理过，并且已经包含至少4个私有内部类或结构。我可以用任何方法在包含对象的构造函数中创建一个双初始化一次的POD数组吗？我如何初始化正在初始化双精度静态数组？我遇到了错误（如更新的OP所示）。似乎所有内容都需要显式初始化，并妨碍编程初始化。您仍然需要在类之外的源文件中定义
静态双精度WEIGHTATI[NUMTRACES]
：
双精度meclass:：WEIGHTATI[NUMTRACES]；
。您的构造函数应该与类同名：
meclass:：meclass（）
。PIMPL是子类的一个名称，meclass只是一个包装器。
double meclass:：WEIGHTATI[NUMTRACES]
是一个声明而不是定义。由于这都在正文中，我把它们作为非成员变量放在顶部。任何非常量静态成员变量都应该在类中声明，并在类外定义一次。子类不能访问超类中的私有变量，因此需要对其进行保护。这里的第二条注释可以工作并生成更优雅的代码。谢谢
// foo.h

class Foo {
  static const int MIDTRACE = 3; // static const, no definition needed
  static const int NUMTRACES = 2 * MIDTRACE + 1; // static const, no definition needed
  static double WEIGHTATI[NUMTRACES]; // not const, so need definition outside of class
public:
  Foo() {
    static bool array_initialized = false;
    if( !array_initialized ) {
      // Initialize array
      array_initialized = true;
    }
  }
  // Other members
};

// foo.cpp
include "foo.h"
double Foo::WEIGHTATI[NUMTRACES];