C 结构中的内存分配

我的代码使用两种结构，block和layout（任意数量的块的集合）

我正在使用此函数根据一组块快速初始化（并部分填充）结构布局：

struct layout init_layout(int block_no, struct block *blocks){
    struct layout new_layout;
    int i, j;

    new_layout.no = (unsigned short int)block_no;
    // the following two lines cause an memory corruption error
    new_layout.blocks = (struct block *)malloc(block_no);
    new_layout.moves = (short int **)malloc(block_no);
    for(i = 0; i < block_no; i++){
        new_layout.blocks[i] = blocks[i];
        new_layout.moves[i] = (short int *)malloc(2);
        for(j = 0; j < 2; j++)
            new_layout.moves[i][j] = 0;
    }

    return new_layout;
}

struct layout init_layout（int block_no，struct block*blocks）{
结构布局-新建布局；
int i，j；
new_layout.no=（无符号短int）块号；
//以下两行导致内存损坏错误
新的布局块=（结构块*）malloc（块号）；
新布局移动=（短整数**）malloc（块编号）；
对于（i=0；i

到目前为止，我看不出它有什么问题。然而，当我调用这样的函数时

int main(int argc, char** argv){
    // just some arbitrary values for 10 blocks
    int size[2] = {2, 2};
    struct block *blocks = (struct block *)malloc(10);
    for(length = 0; length < 10; length++){
        blocks[length] = init_block('R', 1, size);
    }

    struct layout puzzle;
    puzzle = init_layout(10, blocks);
    return 0;
}

int main（int argc，char**argv）{
//只是10个块的一些任意值
int size[2]={2，2}；
结构块*块=（结构块*）malloc（10）；
用于（长度=0；长度<10；长度++）{
块[长度]=初始块（'R'，1，大小）；
}
结构布局难题；
拼图=初始布局（10块）；
返回0；
}

最后出现内存损坏错误，如init_layout（）中的注释所示。

---

在我的实现中我遗漏了什么？

当你为任何事情分配内存时，你需要仔细分析--“我分配内存的目的是什么？”

在下面，您错误地假设对任意数的

块\u no

进行强制转换将充分调整

新布局。块

和

新布局。移动

所需的内存大小--它不会：

new_layout.blocks = (struct block *)malloc(block_no);
new_layout.moves = (short int **)malloc(block_no);

您为

新布局分配的块实际上是
结构块*块的空间（指向结构块的指针），而您可以
malloc（块号*sizeof（结构块））
要为
块\u no
结构块分配空间，最好根据您正在创建的内容进行分配（即数组
新布局块的空间）
（同样是指向结构块的指针）它需要
block\u no*sizeof*new\u布局。block
内存字节以容纳
struct block
类型的
block\u no
，例如：

new_layout.blocks = malloc(sizeof *new_layout.blocks * block_no);
new_layout.moves = malloc(sizeof *new_layout.moves * block_no);

（简单地取消对正在分配数组的对象的引用，将允许您使用
sizeof
获得数组的对象（元素）大小。（例如
sizeof*new\u layout.blocks
）乘以所需数量（例如
sizeof*new\u layout.blocks*block\u no）

这同样适用于：

    new_layout.moves[i] = malloc(**new_layout.moves * 2);

（注意：这里您分配的是2条短消息，因此您需要两次取消对指向短消息的指针的引用，以便分配
sizeof（short）
）

另请参阅：以获得详细解释。
当您为任何内容分配内存时，您需要仔细分析--“我分配内存的目的是什么？”

在下面，您错误地假设对任意数的
块\u no
进行强制转换将充分调整
新布局。块
和
新布局。移动
所需的内存大小--它不会：

new_layout.blocks = (struct block *)malloc(block_no);
new_layout.moves = (short int **)malloc(block_no);

您为
new\u layout.blocks
分配的实际上是
struct block*块的空间；
（指向struct block的指针），而您可以
malloc（block\u no*sizeof（struct block））；
为
block\u no
struct block分配空间，最好根据您创建的内容进行分配（即数组
新布局的空间。块
（再次指向结构块的指针），它需要
块号*大小*新布局。块
字节的内存来容纳
块号
类型的
结构块
，例如：

new_layout.blocks = malloc(sizeof *new_layout.blocks * block_no);
new_layout.moves = malloc(sizeof *new_layout.moves * block_no);

（简单地取消对正在分配数组的对象的引用，将允许您使用
sizeof
获得数组的对象（元素）大小。（例如
sizeof*new\u layout.blocks
）乘以所需数量（例如
sizeof*new\u layout.blocks*block\u no）

这同样适用于：

    new_layout.moves[i] = malloc(**new_layout.moves * 2);

（注意：这里您分配的是2条短消息，因此您需要两次取消对指向短消息的指针的引用，以便分配
sizeof（short）
）

另请参见：以获得详细解释。
对于初学者，此

  new_layout.blocks = (struct block *)malloc(block_no);

应该是

  new_layout.blocks = malloc(block_no * sizeof *new_layout.blocks);

对于
移动
这有点复杂

假设
short int**moves；
应该引用一定数量的
int[2]
声明不是最优的，最好是：

   short int (*moves)[2]; /* Define a pointer to 
                              an array with two elements of type short int. */

然后分配应该如下所示：

  new_layout.moves = malloc(block_no * sizeof *new_layout.moves);

  for(i = 0; i < block_no; i++){
    new_layout.blocks[i] = blocks[i];
    for(j = 0; j < sizeof new_layout.moves[0]/sizeof new_layout.moves[0][0]; j++)
        new_layout.moves[i][j] = 0;
  }

最后，初始化如下所示：

  new_layout.moves = malloc(block_no * sizeof *new_layout.moves);

  for(i = 0; i < block_no; i++){
    new_layout.blocks[i] = blocks[i];
    for(j = 0; j < sizeof new_layout.moves[0]/sizeof new_layout.moves[0][0]; j++)
        new_layout.moves[i][j] = 0;
  }

（i=0；i{
新的_布局。块[i]=块[i]；
对于（j=0；j

你可能已经注意到：


循环中不再有内存分配
幻数
2
只出现一次

：-）
首先

  new_layout.blocks = (struct block *)malloc(block_no);

应该是

  new_layout.blocks = malloc(block_no * sizeof *new_layout.blocks);

对于
移动
这有点复杂

假设
short int**moves；
应该引用一定数量的
int[2]
声明不是最优的，最好是：

   short int (*moves)[2]; /* Define a pointer to 
                              an array with two elements of type short int. */

然后分配应该如下所示：

  new_layout.moves = malloc(block_no * sizeof *new_layout.moves);

  for(i = 0; i < block_no; i++){
    new_layout.blocks[i] = blocks[i];
    for(j = 0; j < sizeof new_layout.moves[0]/sizeof new_layout.moves[0][0]; j++)
        new_layout.moves[i][j] = 0;
  }

最后，初始化如下所示：

  new_layout.moves = malloc(block_no * sizeof *new_layout.moves);

  for(i = 0; i < block_no; i++){
    new_layout.blocks[i] = blocks[i];
    for(j = 0; j < sizeof new_layout.moves[0]/sizeof new_layout.moves[0][0]; j++)
        new_layout.moves[i][j] = 0;
  }

（i=0；i{
新的_布局。块[i]=块[i]；
对于（j=0；j

你可能已经注意到：


循环中不再有内存分配
幻数
2
只出现一次

：-）
在main中也存在同样的问题：malloc（10*sizeof（struct block））您应该详细说明一下。只需提供一些代码就可以