初始化非整数的巨大常量多维数组的最佳方法是什么？答案

【问题标题】：What is the best way to initialize huge constant multidimensional arrays that are not integers?初始化非整数的巨大常量多维数组的最佳方法是什么？
【发布时间】：2018-08-30 21:33:02
【问题描述】：

我正在尝试将美国海军天文台制作的 solar position algorithm(aka "spa") 的适应功能扭曲到我的课程代码中，这样我就可以轻松地调用一个计算太阳位置的方法。

以下代码来自 USNO 的源代码。我正在尝试初始化列表 L_TERMS、B_TERMS 和 R_TERMS

#define L_COUNT 6
#define B_COUNT 2
#define R_COUNT 5
#define Y_COUNT 63

#define L_MAX_SUBCOUNT 64
#define B_MAX_SUBCOUNT 5
#define R_MAX_SUBCOUNT 40

enum {TERM_A, TERM_B, TERM_C, TERM_COUNT};
enum {TERM_X0, TERM_X1, TERM_X2, TERM_X3, TERM_X4, TERM_X_COUNT};
enum {TERM_PSI_A, TERM_PSI_B, TERM_EPS_C, TERM_EPS_D, TERM_PE_COUNT};
enum {JD_MINUS, JD_ZERO, JD_PLUS, JD_COUNT};
enum {SUN_TRANSIT, SUN_RISE, SUN_SET, SUN_COUNT};

#define TERM_Y_COUNT TERM_X_COUNT

const int l_subcount[L_COUNT] = {64,34,20,7,3,1};
const int b_subcount[B_COUNT] = {5,2};
const int r_subcount[R_COUNT] = {40,10,6,2,1};

const double L_TERMS[L_COUNT][L_MAX_SUBCOUNT][TERM_COUNT]=
 { ... }; // contains 3*(64+34+20+7+3+1) = 387 doubles
const double B_TERMS[B_COUNT][B_MAX_SUBCOUNT][TERM_COUNT]=
 { ... }; // contains 3*(5+2) = 21 doubles
const double R_TERMS[R_COUNT][R_MAX_SUBCOUNT][TERM_COUNT]=
 { ... }; // contains 3*(40+10+6+2+1) = 177 doubles

我在使用构造函数初始化数组时遇到了麻烦。我尝试使用初始化列表，但它似乎不起作用。如果我在构造函数中初始化数组，一切都很好，但不会在其他方法的范围内，因为我无法在标题中声明它们。我不能像 const int array 那样初始化它们。

有没有更好的方法来初始化我不知道的多维 const double 数组？

注意：USNO 编写的源代码是用 C 编写的，但我正在尝试在 C++ 中使用它。我应该只包含他们的文件并调用计算功能吗？

【问题讨论】：

提示：不要使用数组，使用std::vector。
提示：使用现有的矩阵库。
@tadman 为什么要使用vector 而不是已知大小的数组????
尝试改用std::array。
@tadman: std::vector 不适合这个目的。 std::array 更好。

标签： c++ arrays multidimensional-array initialization-list

【解决方案1】：

您绝对可以使用初始化列表。不过，我在做这种事情时喜欢做的事情是开始时要小得多。从小得多的数组开始，这样更易于管理。

int main()
{
    const double d[2][3][4] =
    {
        {
            { 0.1, 0.2, 0.3, 0.4 },
            { 0.5, 0.6, 0.7, 0.8 },
            { 0.9, 1.0, 1.1, 1.2 }
        },
        {
            { 0.1, 0.2, 0.3, 0.4 },
            { 0.5, 0.6, 0.7, 0.8 },
            { 0.9, 1.0, 1.1, 1.2 }
        },
    };
}

这里我们声明d为2 x 3 x 4。所以我们可以使用d[0]和d[1]，而d[0][2]和d[1][2][3]是最后一个元素。

这是打印的各种内容，注意我一直很懒，只是用相同的元素声明了外部数组：

std::cout << d[0][0][0] << ", " << d[1][0][0] << "\n"; // prints 0.1, 0.1
std::cout << d[0][2][3] << ", " << d[1][2][3] << "\n"; // prints 1.2, 1.2
std::cout << d[0][1][2] << ", " << d[1][1][2] << "\n"; // prints 0.7, 0.7

希望这能让它更清楚。请注意，没有理由像我一样留下线条，我只是觉得它更容易阅读。

【讨论】：

我能理解这么多。但是你会如何在课堂上做到这一点？它必须在头文件中声明，以便每个方法都可以读取它，但只能在构造函数中定义。

【解决方案2】：

所以在初始化列表中，你可以使用 () 或 {}，而不是 ({})。因此，例如初始化数组应该使用以下行：

class Foo::Foo() : L_TERMS{{{ ... }}}, // rest of initialization

而不是

class Foo::Foo() : L_TERMS( {{{ ... }}} ) // rest of initialization

【讨论】：