C 代码在调试模式下工作正常，但在正常运行时失败

这在我使用指针时经常发生。今天我有一个类似问题的代码。当我在调试模式下运行下面的代码时，代码执行得非常好，并在代码块13.12中正常退出

当我尝试在正常模式下运行它时，它似乎遇到了分段错误，从而导致代码终止。在执行打印板功能的过程中，代码基本中断。但我不知道为什么会发生这种情况

这是我的密码：

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

#define boardheight 8
#define boardwidth 8
struct Player_symbols{
    char symbol;
    char king_symbol;
};

struct Checker_piece{
    char king;
    int on_board;
    int num_moves;
    int player;
    struct Player_symbols* symbols;
};

int pieces_count[2] = {12,12};
struct Checker_piece* player_1_pieces;
struct Checker_piece* player_2_pieces;

void initialize_player_pieces(struct Checker_piece* player_pieces, struct Player_symbols* player_symbols, int player_num);
void initialize_board(struct Checker_piece* checker_board[boardheight][boardwidth],struct Checker_piece* player1,struct Checker_piece* player2);
void print_board(struct Checker_piece* checker_board[boardheight][boardwidth]);
int move_piece(struct Checker_piece* checker_board[boardheight][boardwidth], int x,int y,int player);
void continue_jumping(struct Checker_piece* checker_board[boardheight][boardwidth],int* y,int* x,int player);
int generate_destination(int x, int *dest_x, int *dest_y, int *dest_y_jump,int dest_y2,int dest_y2_jump,int move_flags,int player);

int main()
{
    struct Checker_piece*  checker_board[boardheight][boardwidth];
    //declare and initialize the Checker_piece structures by allocating memory dynamically using a dummy structure to determine its size
    player_1_pieces = malloc(12*sizeof (struct Checker_piece));
    player_2_pieces = malloc(12*sizeof (struct Checker_piece));
    struct Player_symbols *player_1_symbols,*player_2_symbols;

    player_1_symbols = malloc(sizeof (struct Player_symbols));
    player_2_symbols = malloc(sizeof (struct Player_symbols));

    //initialize the player symbols
    player_1_symbols->symbol = 'o';
    player_1_symbols->king_symbol = 'O';
    player_2_symbols->symbol = 'x';
    player_2_symbols->king_symbol = 'X';

    initialize_player_pieces(player_1_pieces,player_1_symbols,1);
    initialize_player_pieces(player_2_pieces,player_2_symbols,2);
    initialize_board(checker_board,player_1_pieces,player_2_pieces);
    print_board(checker_board);
    return 0;
}

void initialize_player_pieces(struct Checker_piece* player_pieces, struct Player_symbols* player_symbols, int player_num){
    int i;
    for (i = 0; i < 12; i++, player_pieces++ ) {
        player_pieces->king='N';
        player_pieces->num_moves=0;
        player_pieces->on_board=1;
        player_pieces->player=player_num;
        player_pieces->symbols= player_symbols;
    }
}

void initialize_board(struct Checker_piece* checker_board[boardheight][boardwidth],
                      struct Checker_piece* player1,struct Checker_piece* player2)
{
    int i, j;
    for(i = 0; i < 3; i++) {
        for(j = 0; j <= 7; j = j+2) {
            if(i == 0 || i % 2 == 0) {
                checker_board[i][j+1] = player1;
                checker_board[i][j] = malloc(sizeof (struct Checker_piece));
            } else {
                checker_board[i][j] = player1;
                checker_board[i][j+1] = malloc(sizeof (struct Checker_piece));
            }
            player1++;
        }
    }
    for(; i < 5; i++){
        for(j = 0; j < 8; j++){
            checker_board[i][j] = malloc(sizeof (struct Checker_piece));
        }
    }
    for(i = 5; i < 8; i++){
        for(j = 0; j <= 7; j = j+2){
            if(i == 0 || i % 2 == 0){
                checker_board[i][j+1] = player2;
                checker_board[i][j] = malloc(sizeof (struct Checker_piece));
            } else {
                checker_board[i][j] = player2;
                checker_board[i][j+1] = malloc(sizeof (struct Checker_piece));
            }
            player2++;
        }
    }
}
void print_board(struct Checker_piece* checker_board[boardheight][boardwidth]){
    int i = 0,j = 0;
    printf("\n   1   2   3   4   5   6   7   8\n");
    printf(" |---|---|---|---|---|---|---|---|\n");

    for(i = 0; i < 8; i++) {
        printf("%d|",(i + 1));
        for(j = 0; j < 8; j++) {
                if(checker_board[i][j]->king != '\r')
                    printf(" %c |",checker_board[i][j]->symbols->symbol);
                else
                    printf("   |");
        }
        printf("\n");
        printf(" |---|---|---|---|---|---|---|---|\n");
    }
}

#包括
#包括
#定义板高8
#定义板宽8
struct Player_符号{
字符符号；
字符king_符号；
};
结构检查器{
炭王；
板上的int；
int num_移动；
国际球员；
struct Player_符号*符号；
};
整数块数[2]={12,12}；
结构棋盘格棋子*玩家棋子1棋子；
结构棋盘格棋子*玩家棋子；
无效初始化玩家棋子（结构棋子棋子*玩家棋子，结构玩家棋子*玩家棋子，整数玩家棋子）；
无效初始化棋盘（结构棋盘格棋盘格棋盘格棋盘[棋盘高度][棋盘宽度]、结构棋盘格棋盘格棋盘格棋盘格棋盘格棋盘格棋盘格棋盘格棋盘格棋盘格棋盘格棋盘格棋盘格棋盘格棋盘格棋盘格棋盘格棋盘格棋盘格棋盘格棋盘格棋盘格棋盘格；
无效打印板（结构棋盘格*棋盘格[boardheight][boardwidth]）；
内部移动块（结构棋盘格棋盘格棋盘格[boardheight][boardwidth]，内部x，内部y，内部播放器）；
无效继续跳（结构棋盘格棋子棋盘格棋盘[boardheight][boardwidth]，int*y，int*x，int-player）；
int生成目的地（int x、int*目的地x、int*目的地y、int*目的地y跳转、int目的地y2、int目的地y2跳转、int移动标志、int玩家）；
int main（）
{
结构棋盘格*棋盘格[boardheight][boardwidth]；
//通过使用虚拟结构动态分配内存来确定其大小，从而声明并初始化棋盘格结构
player_1_件=malloc（12*sizeof（结构检查器_件））；
player_2_件=malloc（12*sizeof（结构检查器_件））；
结构游戏者符号*游戏者符号，游戏者符号；
player_1_symbols=malloc（sizeof（struct player_symbols））；
player_2_symbols=malloc（sizeof（struct player_symbols））；
//初始化播放器符号
玩家_1_符号->符号='o'；
玩家符号->国王符号='O'；
玩家2_符号->符号='x'；
玩家符号->国王符号='X'；
初始化玩家棋子（玩家棋子，玩家符号，1）；
初始化玩家棋子（玩家棋子，玩家棋子符号，2）；
初始化棋盘（棋盘、棋手棋盘、棋手棋盘、棋手棋盘）；
打印板（棋盘）；
返回0；
}
无效初始化玩家棋子（结构棋子棋子*玩家棋子，结构玩家棋子*玩家棋子，整数玩家棋子）{
int i；
对于（i=0；i<12；i++，player_件++）{
玩家的棋子->国王；
玩家棋子->移动次数=0；
玩家棋子->棋盘上=1；
玩家\u个->玩家=玩家\u个；
玩家棋子->符号=玩家符号；
}
}
无效初始化棋盘（结构棋盘格棋子*棋盘格棋盘[boardheight][boardwidth]，
结构检查器\u件*播放器1，结构检查器\u件*播放器2）
{
int i，j；
对于（i=0；i<3；i++）{
对于（j=0；j符号->符号）；
其他的
printf（“|”）；
}
printf（“\n”）；
printf（“|-|-|-|-|-|-|-|-|-| \n”）；
}
}

查看源代码并使用调试器时，我已确认问题： 1-在print_board（）中，如果检查未使用“\'r”的值，则执行以下测试：

if(checker_board[i][j]->king != '\r')

2-在initialize_board（）中，至少对于'king'参数，所有malloc（）都未初始化：

void initialize_board(struct Checker_piece* checker_board[boardheight][boardwidth],
                      struct Checker_piece* player1,struct Checker_piece* player2)
{
    int i, j;
    for(i = 0; i < 3; i++) {
        for(j = 0; j <= 7; j = j+2) {
            if(i == 0 || i % 2 == 0) {
                checker_board[i][j+1] = player1;
                checker_board[i][j] = malloc(sizeof (struct Checker_piece));
                // init at least the king to '\r'
                checker_board[i][j]->king = '\r';
            } else {
                checker_board[i][j] = player1;
                checker_board[i][j+1] = malloc(sizeof (struct Checker_piece));
                checker_board[i][j+1]->king = '\r';
            }
            player1++;
        }
    }
    for(; i < 5; i++){
        for(j = 0; j < 8; j++){
            checker_board[i][j] = malloc(sizeof (struct Checker_piece));
            checker_board[i][j]->king = '\r';
        }
    }
    for(i = 5; i < 8; i++){
        for(j = 0; j <= 7; j = j+2){
            if(i == 0 || i % 2 == 0){
                checker_board[i][j+1] = player2;
                checker_board[i][j] = malloc(sizeof (struct Checker_piece));
                checker_board[i][j]->king = '\r';
            } else {
                checker_board[i][j] = player2;
                checker_board[i][j+1] = malloc(sizeof (struct Checker_piece));
                checker_board[i][j+1]->king = '\r';
            }
            player2++;
        }
    }
}

void初始化棋盘（结构棋盘格棋子*棋盘格棋盘[boardheight][boardwidth]，
结构检查器\u件*播放器1，结构检查器\u件*播放器2）
{
int i，j；
对于（i=0；i<3；i++）{
对于（j=0；j-king='\r'；
}否则{
棋盘[i][j]=player1；
棋盘[i][j+1]=malloc（结构棋盘的尺寸）；
棋盘[i][j+1]->king='\r'；
}
player1++；
}
}
对于（；i<5；i++）{
对于（j=0；j<8；j++）{
棋盘[i][j]=malloc（结构棋盘的尺寸）；
棋盘[i][j]->king='\r'；
}
}
对于（i=5；i<8；i++）{
对于（j=0；j-king='\r'；
}否则{
棋盘[i][j]=player2；
棋盘[i][j+1]=malloc（结构棋盘的尺寸）；
棋盘[i][j+1]->king='\r'；
}
player2++；
}
}
}

如果

j=6

，你认为这一行会发生什么情况？问题出在print_board函数的某个地方。其余代码工作正常。我通过注释print_board函数验证了这一事实。在这种情况下，您可能希望理解术语undefined behavior的含义。到目前为止，我理解的是，我在为其分配内存的check_board指针方面面临问题她不愿意给它分配一块。就像棋盘格[0][0]指针那样，你看不出我指出的代码有问题吗？我想这不是唯一的一个。。