在 C++ 处使用 for 循环初始化一系列数组

Question

我尝试使用 for 循环创建一系列多维数组。用户应输入要初始化的数组的数量。我想要这样的东西：

int i;
printf("Enter the number of arrays you want: ");
scanf("%d",i)
for(int j=0;j<i;j++){
     long double x(j)[size][size];
}

如果我输入 5，我想要 x0、x1、x2、x3 和 x4。

有可能吗？

感谢您的帮助。

此致， 埃姆雷.

Answer 1

编辑：刚刚注意到您正在使用 C++。在这种情况下，std::vector绝对是最方便的解决方案。如果您对如何使用 C 风格的普通数组执行此操作感到好奇，请继续阅读...

---

您不能这样做。你需要做的是创建一个 3 维数组（或一个 2 维数组的数组，这取决于你的观点......）

与 C 的情况一样，内存分配是一个痛苦......你可以静态地allocate:

long double x[N][size][size];

(N 在编译时确定。确保它足够大。
另外，如果 N 确实很大，请以静态方式声明数组（作为全局变量或使用 static 关键字）。如果你不这样做，你可能会得到堆栈溢出。）

或者你可以使用动态内存分配：

long double (*x)[size][size]; // x is a pointer to size by size arrays
x = malloc(n * sizeof(*x));
//You can now use x[j][a][b]...

也许使用 typedef 看起来会更好（即使我不能 100% 确定我在上一个例子中得到了正确的数组声明...... ）：

typedef long double typename_here[size][size];
typename_here *x;
x = malloc(n * sizeof(typename_here);

---

顺便说一句，您当前的代码不起作用的原因是

1. x(j) 语法是虚构的:)
2. 在循环内声明的变量是该块的内部变量。这意味着您无法在循环体之后访问它们。

Answer 2

如果您使用 C++，您最好使用 std::vector 作为：

//single dimensional array of double of size 20
std::vector<double>  v1double (20);      
//use like v[i] where  0 <= i < 20

//two dimensional array of double of size  (10 * 20)
std::vector<std::vector<double> >  v2double(10, v1double ); 
//use like v[i][j] where  0 <= i < 10 and 0 <= j < 20

//three dimensional array of double of size (5 * 10 * 20)
std::vector<std::vector<std::vector<double> >  v3double (5, v2double); 
//use like v[i][j][k] where  0 <= i < 5 and 0 <= j < 10 and 0 <= k < 20

Answer 3

一组多维数组与多一个维度的多维数组是一样的。

另外，关于内置数组的一些事情：

• 在 C++ 中，内置数组维度必须基于编译时常量。您无法计算大小、从文件中读取它、从用户输入中获取它等。
• 要创建具有可变大小的内置数组，您必须分配内存，并像指针一样使用它
• 要为内置数组分配内存-in 数组要在 C 和 C++ 之间移植，您必须使用 malloc，并确保稍后对从 malloc 获得的所有内容调用 free （有时很难做到正确）

如果您使用的是 C++，并且不需要使用 C 编译器编译代码，我建议使用 vector 而不是内置数组。向量不必具有恒定的大小，并且可以在您想要调整大小时调整大小，通常无需在代码中调用 malloc 或 new

一种方法这看起来像：

#include<iostream>
#include<vector>

int main(int argc, char* argv[])
{
    std::cout << "Enter the number of arrays you want:" << std::endl;

    const int size = 4;
    const int initial_value = 0;
    int i;
    std::cin >> i;

    std::vector<int> sub_sub_array(size, initial_value);
    std::vector<std::vector<int> > sub_array(size, sub_sub_array);
    std::vector<std::vector<std::vector<int> > > array(i, sub_array);

    array[0][1][2] = 5;

    // Print out the full array contents
    for(size_t i = 0; i < array.size(); ++i)
    {
        for(size_t j = 0; j < size; ++j)
        {
            for(size_t k = 0; k < size; ++k)
            {
                std::cout << "(" << j << ", " << k << ") - " << array[i][j][k] << ", ";
            }
            std::cout << "\n";
        }
        std::cout << "\n";
    }
}

输入您想要的阵列数量：
2

(0, 0) - 0, (0, 1) - 0, (0, 2) - 0, (0, 3) - 0,
(1, 0) - 0, (1, 1) - 0, (1, 2) - 5, (1, 3) - 0,
(2, 0) - 0, (2, 1) - 0, (2, 2) - 0, (2, 3) - 0,
(3, 0) - 0, (3, 1) - 0, (3, 2) - 0, (3, 3) - 0,

(0, 0) - 0, (0, 1) - 0, (0, 2) - 0, (0, 3) - 0,
(1, 0) - 0, (1, 1) - 0, (1, 2) - 0, (1, 3) - 0,
(2, 0) - 0, (2, 1) - 0, (2, 2) - 0, (2, 3) - 0,
(3, 0) - 0, (3, 1) - 0, (3, 2) - 0, (3, 3) - 0,

编辑：

上述解决方案的唯一问题是您可能能够也可能无法在需要内置数组的代码中使用它。从你的评论来看，你需要它。

如果您现有的代码可以一次接受一行，那么上述解决方案将起作用。如果它只能接受二维数组，则必须使用不同的向量结构。请参阅此问题了解原因：

传递嵌套 C++ 向量作为内置样式多维数组

如果您需要一组连续的二维数组，这里有一些选项：

std::vector<int*> array_instances(i);
for(size_t j = 0; j < array_instances.size(): ++j)
    array_instances[j] = new int[size * size];

for(size_t j = 0; j < array_instances.size(); ++j)
    existing_code(array_instances[j]);

// When done with the arrays
for(size_t j = 0; j < array_instances.size(): ++j)
    delete[] array_instances[j]; // Make sure to include the brackets after "delete"

或者：

std::vector<int> template_array(size * size, 0);
std::vector<std::vector<int> > array_instances(i, template_array);

for(size_t j = 0; j < array_instances.size(); ++j)
    existing_code(&array_instances[j][0]);