预期的表达，这里的预期答案

【问题标题】：expected expression ,what is expected here预期的表达，这里的预期
【发布时间】：2022-07-19 21:20:38
【问题描述】：

int **A;
    A=(int**)malloc(3*sizeof(int*));
    
    A[0]=(int *)malloc(4*sizeof(int));
    A[1]=(int *)malloc(4*sizeof(int));
    A[2]=(int *)malloc(4*sizeof(int));
    
    A[3][4]={{1,2,3,4},{1,2,3,4},{1,2,3,4}};
    
    for(int i=0;i<3;i++)
    {
        for(int j=0;j<4;j++)
            printf("%d ",A[i][j]);
        printf("\n");
    }

}

这里显示“预期的表达”我该怎么办，请帮帮我。

【问题讨论】：

错误信息包含行号。您应该显示完整的确切错误消息。
A[3][4] 是由赋值运算符分配的int 对象（左值），{{1,2,3,4},{1,2,3,4},{1,2,3,4}} 不是表达式。它看起来更像是一个初始化程序。
Initializing C dynamic arrays
A[3][4]={{1,2,3,4},{1,2,3,4},{1,2,3,4}}; 这是对已分配数组的不存在字段的赋值（A[3][4]，而最大索引为 A[2][3]。此外，此语法仅在数组初始化中允许，在分配中不允许.

标签： c

【解决方案1】：

A[3][4]={{1,2,3,4},{1,2,3,4},{1,2,3,4}};

肯定是错的。

您可以通过引用现有数组或复合文字来分配已分配数组的指针元素。但是根据您的伪代码，不可能将它用作二维数组，只能使用一维数组。

A[3]=(int[]){1,2,3,4,5,6,7,8,9,0};

或

int B[] = {1,2,3,4,5,6,7,8,9,0};
A[3] = B;

A[3] 超出范围，因此您还需要更改 malloc。

A = malloc(4 * sizeof(*A));

也不要转换malloc 的结果。如果你的代码不能编译，说明你使用C++编译器编译的C代码不正确

【讨论】：

【解决方案2】：

在此声明中

A[3][4]={{1,2,3,4},{1,2,3,4},{1,2,3,4}};

您正在尝试将花括号列表中的值分配给 int 类型的标量对象，因为索引 3 和 4 访问动态分配数组之外的内存，所以该对象甚至不存在。

注意数组没有赋值运算符。您需要将一个数组的元素复制到另一个数组中。

您最初可以声明一个数组并使用大括号列表对其进行初始化

int A[3][4]={{1,2,3,4},{1,2,3,4},{1,2,3,4}};

对于动态分配的数组，如果像 for 循环这样的例子，你可以初始化它们的元素

for ( size_t i = 0; i < 3; i++ )
{
    int value = 1;
    for ( size_t j = 0; j < 4; j++ )
    {
        A[i][j] = value++;
    }
}

【讨论】：

【解决方案3】：

我认为没有理由在这里做不止一个malloc（甚至可能不是那个）。

在下面，您尝试将所有值分配给 2D 数组中的单个元素（并且它也超出了范围，因为 A[2][3] 是最后一个可访问的元素）。

A[3][4]={{1,2,3,4},{1,2,3,4},{1,2,3,4}}

您可以改为memcpy。

例子：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main() {
    int(*A)[4] = malloc(3 * sizeof *A); // only one allocation

    // "assign" all values to where A points:
    memcpy(A, (int[3][4]){{1, 2, 3, 4},{1, 2, 3, 4},{1, 2, 3, 4}}, 3 * sizeof *A);

    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 4; j++) printf("%d ", A[i][j]);
        printf("\n");
    }

    free(A) // only one deallocation
}

【讨论】：