Malloc编译错误：类型为“的值”；int"；无法用于初始化int（*）类型的实体[30]

到现在为止，我肯定已经试过20种方法了。我真的需要帮助，无论我做什么，我都会遇到类似的错误

a value of type "int" cannot be used to initialize an entity of type "int (*)[30]"

i、 这会让我犯这样的错误

int(*array)[160] = malloc((sizeof *array) * 10);

做这样的事情

int** Make2DintArray(int arraySizeX, int arraySizeY) {
    int** theArray;
    theArray = (int**) malloc(arraySizeX*sizeof(int*));
    int i;
    for (i = 0; i < arraySizeX; i++)
    {
        theArray[i] = (int*) malloc(arraySizeY*sizeof(int));
    }
    return theArray;
}

有没有人有办法成功分配int[160][10]的2dArray来分配数组：

int *array = malloc(sizeof(int) * 160 * 10);

然后使用如下代码：

array[10 * row + column] = value;

（其中，

行

从0到159，列从0到9。）

int **array;
array = malloc(rows * sizeof(int *));
for (i = 0; i < rows; i++)
  array[i] = malloc(cols * sizeof(int));

// Some testing
for (i = 0; i < rows; i++) {
  for (j = 0; j < cols; j++)
    array[i][j] = 0; // or whatever you want
}

for (i = 0; i < rows; i++) {
  for (j = 0; j < cols; j++)
    printf("%d ", array[i][j]);
}

int**数组；
数组=malloc（行*sizeof（int*）；
对于（i=0；i

在您的例子中，rows=160，cols=10。这是一种可能的解决办法

---

通过这种方法，您可以使用两个索引：

这两个索引对我来说都很好。第一个错误很常见，当您在使用所述函数（例如

malloc（size\u t）

）之前忘记包含

，我没有忘记这样做

C有一些有趣的编译时行为，其中包括调用以前从未见过的函数的能力（既不是原型定义也不是实现）。遇到此类调用时，C假定函数为：


返回
int
接受未知数量的参数，因此调用方可以传递它想要的任何内容（包括错误的内容）

例如，隐式假设函数的形式为：

int func();

int malloc();

通常情况下，您甚至不会注意到，除了编译器发出的警告，这些警告会报告以下内容：

Warning: implicit declaration of `func` assumed to return `int`

如果你在球上，你有你的警告级别与警告的错误启用，并将赶上这一点

但是如果你没有呢？如果函数返回的“thing”不能由实现
int
中的数据大小表示内容，该怎么办？例如，如果
int
是32位的，但是数据指针是64位的呢？例如，假设
char*get_str（）
在您不包含的某个头文件中声明，并在您编译并与程序链接的.c文件中实现，如下所示：

#include <stdio.h>

// Note: NO prototype for get_str
int main()
{
    char *s = get_str();
    printf("String: %s\n", s);
    return 0;
}

现在，如果没有启用警告作为错误，您将得到一个隐式声明警告，仅此而已。代码将被编译。但它会运行吗？如果
sizeof（int）
！=
sizeof（char*）
，（32位vs 64位）不太可能。从
get_str
返回的值是一个64位指针，但调用者假定只返回32位，然后强制它返回一个64位指针。简言之，演员们隐藏了错误，打开了潘多拉盒子中未定义的行为


那么，所有这些与您的代码有什么关系呢？通过不包含
编译器不知道什么是
malloc
。因此它假设它的形式是：

int func();

int malloc();

然后，通过将结果强制转换为
（int**）
，您告诉编译器“无论结果如何，都将其转换为
int**
”。在链接时，
\u malloc
被找到（没有像C++那样通过名称损坏的参数签名），连接起来，您的程序就准备好参加聚会了。但是在您的平台上，
int
和数据指针的大小不一样，因此您最终会产生一些不良后果：


演员阵容隐藏了真正的错误
伪指针是由实际返回指针的一半位构成的
作为对伤口残酷的一剂盐，分配的内存被泄漏，因为任何地方都没有引用它的有效指针（只保留了一半就破坏了唯一的一个）
如果在
sizeof（int）==sizeof（int**）
的实现上编译代码，则代码可能会表现出正常的行为，这可能是最不可取的

因此，您在32位Debian box上构建了它，一切看起来都很好。你把你的家庭作业交给教授，教授在他的64位Mac上构建了它，然后它崩溃了，你没有通过作业，没有通过课堂，辍学了，在接下来的十年里，你一边在你妈妈的地下室看《宋飞传》重播，一边抚摸着这只猫，想知道出了什么问题。哎哟

不要像对待银弹一样对待铸造。事实并非如此。在C语言中，它的使用频率远远低于人们使用它的频率，如果在错误的地方使用，可能会隐藏灾难性的错误。如果您在代码中发现一个点，如果没有强制转换，某些东西将无法编译，请再次查看。除非你绝对肯定演员是正确的，否则很可能是错误的

在本例中，它隐藏了真正的错误，即您忽略了向编译器提供足够的信息，以了解malloc真正的功能。
我有一个关于rendon答案的注释：

对于他的代码，Visual C++为每一个“=”操作表示：<代码>错误C2440:'=：不能从“空隙*”转换为“int **”/代码> 
通过做一些修改，它对我有效，但我不确定它是否也有效，所以我害怕编辑他的代码。相反，这是我的代码，它似乎能给人留下第一印象

int **a;    

a = (int **)malloc(rows * sizeof(int));

for (i = 0; i < rows; i++)
{
    a[i] = (int *)malloc(cols * sizeof(int));
}

for (j=0;j<rows;j++)
{
    for (i=0;i<cols;i++)
    {
        a[i][j] = 2;
    }
}

int**a；
a=（int**）malloc（rows*sizeof（int））；
对于（i=0；i对于（j=0；j别介意，我只是使用calloc添加了一个示例

void allocate_fudging_array(int R, int C)
{
    int **fudging_array = (int **) calloc(R, sizeof(int *));
    for(int k = 0; k < R; k++)
    {
        fudging_array[k] = (int*) calloc(C, sizeof(int));
    }
}


// a helper function to print the array 
void print2darr(int **arr, int R, int C)
{
    for(int i = 0; i < R; i++)
    {
        for(int j = 0; j < C; j++)
        {
            printf(" %d  ", arr[i][j]);
        }
        printf("\n");
    }
}

void allocate\u fudding\u数组（int R，int C）
{
int**fudding_数组=（int**）calloc（R，sizeof（int*）；
对于（int k=0；k
2
char ***array;
int rows = 2, cols = 2, i, j;
array = malloc(sizeof(char **)*rows);
for (i = 0; i < rows; i++)
  array[i] = malloc(cols * sizeof(char *));

array[0][0] = "asd";
array[0][1] = "qwe";
array[1][0] = "stack";
array[1][1] = "overflow";

for(i=0;i<rows;i++){
  for(j=0;j<cols;j++){
    printf("%s ",array[i][j]);
  }
  printf("\n");
}