C++ 仅初始化只读数组一次

我有一个类，需要使用一些大数组，通过一些复杂函数初始化，每个实例都是一样的，只有在初始化后才会读取

我搜索了SO，找到了一些关于初始化静态数组的答案，如下所示：

char A::a[6] = {1,2,3,4,5,6};

但在我的例子中，我需要在运行时通过一些函数计算数组。

---

（如何）我可以这样做？

您不能在执行时使用{}sintaxis，您可以使用以下方法：

class A
{
   static vector<char> a;
   //...
   public:
   static void initStatic();
}

void A::initStatic()
{
    a.resize( /*put the size here... */);
    for (auto& x : a)
        x = //something...
}

A类
{
静态向量a；
//...
公众：
静态void initStatic（）；
}
void A:：initStatic（）
{
a、 调整大小（/*将大小放在此处…*/）；
用于（自动和x:a）
x=//某物。。。
}

矢量参考：

我的建议：

使用静态成员函数提供对数组的访问，而不是使用静态成员变量

在静态成员函数中，创建可在第一次需要时填充的静态函数变量

以下是我的想法：

char* A::getArray()
{
   static char a[6] = {0};
   static bool inited = false;
   if ( !inited )
   {
      // Initialize the array elements 
      a[0] = ...  ;

      ...

      a[5] = ...  ;

      inited = true;
   }

   return a;
}

再

“对于每个实例都是相同的，只有在初始化后才会读取

生成值是函数的工作

只需定义一个返回所需数据的函数

您可以使用它来初始化静态数据成员（或其他）。对于仅标头模块，如果相关，则需要采用“内联数据”问题的解决方案，例如Meyers的singleton（返回对局部静态变量的引用的函数）。像这样：

#include <vector>

namespace my {
    using std::vector;

    inline
    auto squares()
        -> vector<int>
    {
        vector<int> result;
        for( int i = 1; i <= 12; ++i ) { result.push_back( i*i ); }
        return result;
    }

    class A
    {
    private:
        static
        auto a()
            -> const vector<int>&
        {
            static const vector<int> the_values = squares();
            return the_values;
        }

    public:
        A(){}
    };
}  // namespace my

#包括
名称空间我的{
使用std：：vector；
内联
自动方块（）
->载体
{
矢量结果；
对于（int i=1；i常数向量&
{
静态常量向量_值=平方（）；
返回_值；
}
公众：
A（）{}
};
}//名称空间我的

如果不使用向量，这是可行的。我让

A:：initialize

做这项工作的原因，而不仅仅是调用这些外部定义的函数之一，是因为我们可以而且应该期望数据成员

A

是私有的

//Declare a function pointer type, so you can pass it into A's
//an initialization function takes in the array and its size
typedef void (*initFunction) (char A[], int arraySize); 
//see http://www.cprogramming.com/tutorial/function-pointers.html
//  for more on function pointers

class A
{
public:
  void initialize (initFunction myInitFunction);
  ...
private:
  char a[ARRAYSIZE];
};

void A::initialize (initFunction myInitFunction)
{
   (*myInitFunction) (a, ARRAYSIZE);  
}

...
A myA;
myA.initialize (yourArrayInitializingFunction);

或者，您的初始化函数不接受数组并初始化它们，而是返回数组：

class A
{
public:
  void initialize (const char* aInit);
  ...
};

void A::initialize (const char* aInit)
{
   for (int i = 0; i < ARRAYSIZE: ++i)
     a[i] = aInit[i];
}

...

A myA;
myA.initialize (yourArrayReturningFunction ());

A类
{
公众：
void初始化（const char*aInit）；
...
};
void A：：初始化（const char*aInit）
{
对于（int i=0；i

如果使用向量，代码更简单：

class A
{
public:
  void initialize (const vector<char>& aInit) { a = aInit; }
  ...
private:
  vector<char> a;
};

A类
{
公众：
void初始化（const vector&aInit）{a=aInit；}
...
私人：
载体a；
};

您可以简单地使用一个静态指针，并在运行时通过new/delete为其分配空间。有很多方法可以做到这一点。1-使用一个init函数，您可以在main上首先调用它；2-预计算并执行您现在正在做的事情；3-使用std:：vector，并使用一个初始化函数返回一个向量：std:：vector a:：a=createInitialA（）；4-在A的构造函数中，检查A是否已初始化。如果未初始化，则通过调用（1）中的init函数来初始化它@tux3为什么向初学者推荐危险的工具，如

new

和

delete

？因为OP已经在使用原始数组了，所以我认为这是有意的。但是我同意向量可能是个好主意。也许我们可以试着保持成人和专业，嗯？谢谢。@ПаааФаwh你放了其他引用了吗？哦，因为cpluplus.com以错误、不完整和误导而闻名。@Паааафаааааааааааааааааа“它也必须是一个可变的全局…”小狗：这里有什么特别的“不安全”或“混乱”吗？（提示：没什么；你在装货。或者在装货。不知道是哪个。）为什么要在类

A

？我以前见过很多，但不是作为类成员。@MooingDuck:因为OP显然是针对这样的东西，提到了一个“需要的类”，并举例说明了

char A:：A[6]

。我想我理解，但只是为了确保：只有在A实例第一次调用A:：A时才会调用squares？如果我不需要只包含头的模块，代码是否简化？如果将其放入.h文件中会发生什么？@mfran:是，是（可以简化它，例如使用静态常量数据成员）。