问题

I see you have a C code snippet and you're encountering issues with memory allocation and program hang. Let's address this step by step.

🧙🏾‍♂️: To better understand your issue, could you please provide some additional context? Specifically, I'd like to know what your goal is with this code. Are you trying to create a snake game, and is this part of the initialization?

${🐍}: Certainly! I'm creating a snake game, and this code is part of the initialization process. It's responsible for setting up the game board and allocating memory for it.

🧙🏾‍♂️: Thank you for clarifying. Now, let's take a closer look at your code. It seems that you've allocated memory for the snakeGame struct, but you haven't allocated memory for the board member inside the struct. This could be causing the issue.

${🐍}: You're correct. I initially tried allocating memory in different ways, as shown in the comments, but I still encounter the same issue with program hang and abrupt exits.

🧙🏾‍♂️: I understand. It's important to ensure that you allocate memory for both the snakeGame struct and the board member properly. Here's one way to allocate memory for the board:

game->board = (snakeEntity **)malloc(row * sizeof(snakeEntity *));
for (int i = 0; i < row; i++) {
    game->board[i] = (snakeEntity *)malloc(col * sizeof(snakeEntity));
}

Have you tried this approach?

${🐍}: Yes, I did try this approach, but it didn't resolve the issue.

🧙🏾‍♂️: I see. Let's continue troubleshooting. Could you please share the code where you populate the board with values? There might be an issue there as well.

${🐍}: Certainly, here's the code where I populate the board:

for (int i = 0; i < row; i++) {
    if (i == 0 || i == row - 1) {
        for (int j = 0; j < col; j++) {
            game->board[i][j] = BORDER;    
        }
    } else {
        game->board[i][0] = BORDER;
        game->board[i][col - 1] = BORDER;
    }
}

This code is responsible for creating the border around the game board.

🧙🏾‍♂️: Thank you for sharing that code. It looks fine for setting up the borders. One last thing to check: have you confirmed that the createSnakeGame function is being called correctly from your main function?

${🐍}: Yes, I've called the createSnakeGame function in main. Here's the relevant part of the main function:

snakeGame * game = createSnakeGame();
printf("Success");
return 0;

🧙🏾‍♂️: It appears that the printf statement is not being reached, which suggests an issue with memory allocation. I recommend checking the return value of malloc calls to ensure they are not returning NULL, indicating a failure in memory allocation.

${🐍}: That's a good point. I will check the return values of malloc calls and see if that's the source of the problem.

🧙🏾‍♂️: Excellent! Please check the return values and let me know if you find any issues or if you have further questions. We'll continue from there.

${🐍}: Will do. I'll check the malloc return values and get back to you with the results. Thank you for your guidance.

snakeGame * createSnakeGame()
{
    int row = 10;
    int col = 10;

    snakeGame * game = (snakeGame *) malloc(sizeof(snakeGame));

    game->rows = row;
    game->columns = col;

    for (int i = 0; i < row; i++)
    {
        if (i == 0 || i == row - 1)
        {
            for (int j = 0; j < col; j++)
            {
                game->board[i][j] = BORDER;    
            }
        }
        else
        {
            game->board[i][0] = BORDER;
            game->board[i][col - 1] = BORDER;
        }
    }

    return game;
}

typedef struct 
{
    snakeEntity ** board;
    int rows;
    int columns;
} snakeGame;

typedef enum 
{
    SNAKE_HORIZONTAL,
    SNAKE_VERTICAL,
    SNAKE_UP_RIGHT,
    SNAKE_UP_LEFT,
    SNAKE_DOWN_RIGHT,
    SNAKE_DOWN_LEFT,
    FOOD,
    BORDER,
    EMPTY
} snakeEntity;

int main()
{
    snakeGame * game = createSnakeGame();
    printf("Success");
    return 0;
}

// Adding the array size to the allocated memory
snakeGame * game = (snakeGame *) malloc(sizeof(snakeGame) + (row * col * sizeof(snakeEntity)));

// Allocating memory to each row individually to the size of the column
game->board = (snakeEntity **) malloc(row * sizeof(snakeEntity));
for (int i = 0; i < row; i++)
{
    game->board[i] = (snakeEntity *) malloc(col * sizeof(snakeEntity));
}

// Initialising the board separately
snakeGame * game = (snakeGame *) malloc(sizeof(snakeGame));
snakeEntity ** board = (snakeEntity **) malloc(row * col * sizeof(snakeEntity));
game->board = board;

答案1

得分: 2

你在循环中给board成员分配空间之前没有为其分配空间：game->board[i][j]。

至于snakeEntity ** board = (snakeEntity **) malloc(row * col * sizeof(snakeEntity));，这也是错误的。board**不是一个2D数组，不能像一个2D数组那样使用。但它可以作为指向数组指针中第一个项的指针来使用，以模拟一个2D数组。在这种情况下，正确的用法是：

game->board = malloc(row * sizeof(snakeEntity *));
for(size_t i=0; i<row; i++)
{
  game->board[i] = malloc(col * sizeof(snakeEntity));
}

然后以相同的方式使用free()。

不过，指针到指针版本是简单的（很多糟糕的书籍和不好的老师都在宣扬它）。可以查看 https://stackoverflow.com/questions/42094465/correctly-allocating-multi-dimensional-arrays

有几种方法可以使用2D数组来实现这个，而不是使用指针到指针。一个例子是使用 灵活数组成员。不幸的是，灵活数组成员只支持声明的1D数组，但我们可以将其用作2D数组指针的占位符，然后从不实际访问它，而是将其视为1D数组。

这会以牺牲可读性为代价提供非常高效的代码。示例：

typedef struct 
{
  size_t rows;
  size_t cols;
  snakeEntity board[];
} snakeGame;

然后一次性分配所有内容：

snakeGame* game = malloc (sizeof(snakeGame) + sizeof(snakeEntity[ROWS][COLS]));
game->rows = ROWS;
game->cols = COLS;
...
free(game); // 然后以单行形式释放

`board`没有初始化，但现在指向一个分配的2D数组（填充了垃圾）。

我们可以通过将其强制转换为适当的指针类型来填充它（这是难以阅读的部分）：

```c
snakeEntity (*board)[game->cols] = (snakeEntity(*)[game->cols]) game->board;

现在，我们可以使用这个指针来填充或以其他方式访问2D数组，使用2D数组语法：

for(size_t i=0; i<game->rows; i++)
{
  for(size_t j=0; j<game->cols; j++)
  {
    board[i][j] = whatever;
  }
}

game->board = malloc(row * sizeof(snakeEntity));
for(size_t i=0; i<row; i++)
{
  game->board[i] = malloc(col * sizeof(snakeEntity));
}

typedef struct 
{
  size_t rows;
  size_t cols;
  snakeEntity board[];
} snakeGame;

snakeGame* game = malloc (sizeof(snakeGame) + sizeof(snakeEntity[ROWS][COLS]));
game->rows = ROWS;
game->cols = COLS;
...
free(game); // and later free on a single line

snakeEntity (*board)[game->cols] = (snakeEntity(*)[game->cols]) game->board;

for(size_t i=0; i<game->rows; i++)
{
  for(size_t j=0; j<game->cols; j++)
  {
    board[i][j] = whatever;
  }
}