我可以不使用c中的循环将一维数组复制到二维结构中吗？

如果我有一个像这样声明的大1d数组

1darray = malloc(N*sizeof(double))

我有另一个这样声明的结构

for j:A

  2dstructure[j] = malloc(C[j]*sizeof(double*))     

  for i:B

    2dstructure[j][i] = malloc(D*sizeof(double))

  end
end

A*B=N的大小，表示sizeof（1darray）==sizeof（2dstructure）

---

是否有一种方法可以将一维数组中的内容复制到二维结构而不使用循环？

是的，您可以将二维索引映射到线性一维索引，因此：

int idx = j*B + i;

---

此时，

1darray[idx]

相当于

2dstructure[j][i]

是的，您可以将2D索引映射到线性1D索引，因此：

int idx = j*B + i;

---

在这一点上，

1darray[idx]

相当于

2dstructure[j][i]

假设您有一个1D N元素数组，初始化如下：

double *onedarray = malloc(N*sizeof(double));

double *twoddata = malloc(A*B*sizeof(double));

double **twodstructure = malloc(A*sizeof(double*));
for (int i = 0; i < A; i++)
  twodstructure[i] = &twoddata[i*B];

for (int i = 0; i < A; i++)
  for (int j = 0; j < B; j++)
    printf("%f\n", twodstructure[i][j]);

您需要创建一个2D AxB元素数组，其中a*B=N。您可以将2D数组的数据创建为一个连续的内存块，如下所示：

double *onedarray = malloc(N*sizeof(double));

double *twoddata = malloc(A*B*sizeof(double));

double **twodstructure = malloc(A*sizeof(double*));
for (int i = 0; i < A; i++)
  twodstructure[i] = &twoddata[i*B];

for (int i = 0; i < A; i++)
  for (int j = 0; j < B; j++)
    printf("%f\n", twodstructure[i][j]);

然后分别创建结构，如下所示：

double *onedarray = malloc(N*sizeof(double));

double *twoddata = malloc(A*B*sizeof(double));

double **twodstructure = malloc(A*sizeof(double*));
for (int i = 0; i < A; i++)
  twodstructure[i] = &twoddata[i*B];

for (int i = 0; i < A; i++)
  for (int j = 0; j < B; j++)
    printf("%f\n", twodstructure[i][j]);

您可以通过以下代码以结构化方式访问2D阵列：

double *onedarray = malloc(N*sizeof(double));

double *twoddata = malloc(A*B*sizeof(double));

double **twodstructure = malloc(A*sizeof(double*));
for (int i = 0; i < A; i++)
  twodstructure[i] = &twoddata[i*B];

for (int i = 0; i < A; i++)
  for (int j = 0; j < B; j++)
    printf("%f\n", twodstructure[i][j]);

for（int i=0；i

假设您有一个1D N元素数组，初始化如下：

double *onedarray = malloc(N*sizeof(double));

double *twoddata = malloc(A*B*sizeof(double));

double **twodstructure = malloc(A*sizeof(double*));
for (int i = 0; i < A; i++)
  twodstructure[i] = &twoddata[i*B];

for (int i = 0; i < A; i++)
  for (int j = 0; j < B; j++)
    printf("%f\n", twodstructure[i][j]);

您需要创建一个2D AxB元素数组，其中a*B=N。您可以将2D数组的数据创建为一个连续的内存块，如下所示：

double *onedarray = malloc(N*sizeof(double));

double *twoddata = malloc(A*B*sizeof(double));

double **twodstructure = malloc(A*sizeof(double*));
for (int i = 0; i < A; i++)
  twodstructure[i] = &twoddata[i*B];

for (int i = 0; i < A; i++)
  for (int j = 0; j < B; j++)
    printf("%f\n", twodstructure[i][j]);

然后分别创建结构，如下所示：

double *onedarray = malloc(N*sizeof(double));

double *twoddata = malloc(A*B*sizeof(double));

double **twodstructure = malloc(A*sizeof(double*));
for (int i = 0; i < A; i++)
  twodstructure[i] = &twoddata[i*B];

for (int i = 0; i < A; i++)
  for (int j = 0; j < B; j++)
    printf("%f\n", twodstructure[i][j]);

您可以通过以下代码以结构化方式访问2D阵列：

double *onedarray = malloc(N*sizeof(double));

double *twoddata = malloc(A*B*sizeof(double));

double **twodstructure = malloc(A*sizeof(double*));
for (int i = 0; i < A; i++)
  twodstructure[i] = &twoddata[i*B];

for (int i = 0; i < A; i++)
  for (int j = 0; j < B; j++)
    printf("%f\n", twodstructure[i][j]);

for（int i=0；i

对于您的分配模式，由于第二个循环中有多个分配，您无法进行简单复制。这取决于你真正想要什么。通过将指针设置到当前的1D数组中，以便可以将其作为2D数组进行访问，您可以对一组指针进行一次分配。或者，您可以创建1D数组的副本，然后设置指针（2个分配、1个副本、1个初始化循环）。由于唯一的问题是是否复制原始分配，主要答案将在原始数据上起作用

你有：

int N, A, B;
A = ...;
B = ...;
N = A * B;

double *a_1d = malloc(N * sizeof(double));

...check and load a_1d...

现在，您可以通过以下方式创建二维“阵列”：

double **a_2d = malloc(A * sizeof(double *));

...check that allocation succeeded...

for (int i = 0; i < A; i++)
    a_2d[i] = &a_1d[i * B];

然后，您可以在设置

a_2d

中引用

a_1d\u copy

而不是

a_1d

---

请记住，当需要释放东西时，您需要同时释放

a_1d

和

a_2d

（以及

a_2d\u copy

，如果您正在使用它）。

使用您的分配模式，您无法进行简单的复制，因为第二个循环中有多个分配。这取决于你真正想要什么。通过将指针设置到当前的1D数组中，以便可以将其作为2D数组进行访问，您可以对一组指针进行一次分配。或者，您可以创建1D数组的副本，然后设置指针（2个分配、1个副本、1个初始化循环）。由于唯一的问题是是否复制原始分配，主要答案将在原始数据上起作用

你有：

int N, A, B;
A = ...;
B = ...;
N = A * B;

double *a_1d = malloc(N * sizeof(double));

...check and load a_1d...

现在，您可以通过以下方式创建二维“阵列”：

double **a_2d = malloc(A * sizeof(double *));

...check that allocation succeeded...

for (int i = 0; i < A; i++)
    a_2d[i] = &a_1d[i * B];

然后，您可以在设置

a_2d

中引用

a_1d\u copy

而不是

a_1d

---

请记住，当需要释放物品时，您需要同时释放

a_1d

和

a_2d

（如果您使用的是

a_2d\u copy

。

对不起，我没有很好地解释自己。我想要的是将一维数组中的内容复制到二维结构中，而不使用循环。@Atirag:不，因为上面的代码没有真正创建二维结构，它创建了指向数组的指针数组。相应的内存将不连续。对不起，我没有很好地解释我自己。我想要的是将一维数组中的内容复制到二维结构中，而不使用循环。@Atirag:不，因为上面的代码没有真正创建二维结构，它创建了指向数组的指针数组。相应的内存将不连续。请尝试memcpy（1darray，2darray，sizeof（1darray[0]），lengthOf1DArray）？hmmm但内存不连续（如下面的注释所述）不是一个问题吗？那么我想没有循环是没有办法的。指向指针的指针不是2D数组。C有本机的2D数组，这些数组在内存中是连续的，为什么不使用它们呢？在函数范围中，您可以只使用

double（*A）[n]=malloc（sizeof（double[m][n]）

这样就有了一个连续的分配，您可以通过

a[i][j]

简单地对元素进行寻址。请尝试memcpy（1darray，2darray，sizeof（1darray[0]），lengthOf1DArray）嗯，但是内存不是像下面的注释所提到的那样是连续的，这不是一个问题吗？那么我想没有循环是没有办法的。指向指针的指针不是2D数组。C有本机的2D数组，这些数组在内存中是连续的，为什么不使用它们呢？在函数范围中，您可以只使用

double（*A）[n]=malloc（sizeof（double[m][n]）并且通过它有一个连续的分配，您可以通过
a[i][j]
简单地处理元素。在C中，不要强制执行
malloc
的返回：在C中，不要强制执行
malloc
的返回：