结构中的2D数组

Question

我正在用c进行编程，并为一项家庭作业分配了一个战舰游戏。 我已经为该板（对手板和我的板）创建了一个结构，但是我需要一个2D阵列作为板。 这就是我到目前为止

struct Board
{
        char board[10][10];
        int carrierHits;
        int battleshipHits;
        int destroyerHits;
        int subHits;
        int patrolHits;
};
int initializedBoard() //changed from"myBoard" to "initializedBoard"
{
        struct Board myBoard;
}

我需要初始化电路板以具有所有*，这就是为什么我将其声明为char类型的原因。 我当时在想，也许我可以使用for循环来使电路板由*组成，但我不知道该怎么做，因为未分配内存，电路板[i] [j]不起作用。 我对如何完成这项任务感到非常困惑。 稍后，我将未命中和命中更改为O和X。 请帮助我理解这一点。

Answer 1

我不太了解C，但这似乎行得通：

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

#define ROWS 10
#define COLUMNS 10

struct Board
{
    char board[ROWS][COLUMNS];
    int carrierHits;
    int battleshipHits;
    int destroyerHits;
    int subHits;
    int patrolHits;
};

struct Board myboard;

void initializeBoard(struct Board* board)
{
    memset(board->board, '*', ROWS * COLUMNS);
}

void fireAt(int row, int column)
{
    myboard.board[row][column] = '0';
}

int main()
{
    initializeBoard(&myboard);
    fireAt(4, 5);
    fireAt(4, 6);
    fireAt(4, 7);

// SHOW THE BOARD
        for (int i = 0; i < 10; ++i)
        {
            for (int j = 0; j < 10; ++j)
                printf(" %c", myboard.board[i][j]);
            printf("\n");
        }

    return 0;
}

我不知道你是什么意思

“由于未分配内存，因此board [i] [j]不起作用。”

当您使用struct Board myboard结构创建Board实例时，myboard已为Board结构分配了内存，包括10 x 10字符。 仅当有指针而不是数组但为数组分配了内存时，才需要分配内存。

您也可以使用循环而不是memset来初始化板。

Answer 2

我需要初始化电路板以具有所有*，这就是为什么我将其声明为char类型的原因。 我可以使用for循环使木板由*组成。

使您的功能通用，使其可以为您的功能以及对手板所用。 避免全局变量。

下面提供的函数initializeBoard可以将structure Board的board初始化为任何char值。 如果您改变主意，并决定将'*'替换为其他任何值，则只需要更改参数即可。

void initializeBoard(struct Board* board, char c);

由于未分配内存，因此board [i] [j]不起作用。

只要创建struct Board结构（无论是在堆栈上还是在堆上动态）， board[ROWS][COLUMNS]就会有内存来保存其数据。 通过创建struct Board结构，该结构的所有元素都将获得所需的内存。

稍后我会将O和X的未命中和命中率更改为

您将需要一个set函数来更改特定板单元的内容。

这可以通过以下方式完成：

void setCell(struct Board* board, int row, int column, char c);

您需要提供的board ， row ， column坐标和值c都将放置在板上的适当位置。

您很可能需要一个函数来检查给定坐标下的内容。 这可以通过以下方式完成：

char getCell(struct Board* board, int row, int column);

看一下介绍的简单程序。

祝您编程愉快。 通往编程完美王国的路很长，但始终要从第一步开始。

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

#define ROWS 10
#define COLUMNS 10

struct Board
{
    char board[ROWS][COLUMNS];
    int carrierHits;
    int battleshipHits;
    int destroyerHits;
    int subHits;
    int patrolHits;
};

void initializeBoard(struct Board* board, char c)
{
    for (int i = 0; i < ROWS; i++)
        for (int j = 0; j < COLUMNS; j++)
              board->board[i][j] = c;
}

void showBoard(struct Board* board)
{
    for (int i = 0; i < ROWS; i++)
    {
        for (int j = 0; j < COLUMNS; j++)
        {
            printf(" %c", board->board[i][j]);  
        }   
        printf("\n");
    }
    printf("\n");
}

void setCell(struct Board* board, int row, int column, char c)
{
    board->board[row][column] = c;
}

char getCell(struct Board* board, int row, int column)
{
    return (board->board[row][column]);
}

int main(void)
{
    struct Board my_board;
    struct Board opponent_board;

    initializeBoard(&my_board, '*');
    initializeBoard(&opponent_board, '*');

    if(getCell(&my_board,1,5) == '*')
        setCell(&my_board, 1, 5, ' ' );

    setCell(&my_board, 2, 6, 'X' );
    setCell(&my_board, 3, 7, 'O' );
    setCell(&my_board, 3, 8, 'O' );

    setCell(&opponent_board, 1, 2, 'O' );
    setCell(&opponent_board, 1, 3, 'O' );

    showBoard(&my_board);
    showBoard(&opponent_board);

    return 0;
}

输出：

 * * * * * * * * * *                                                                                                                           
 * * * * *   * * * *                                                                                                                           
 * * * * * * X * * *                                                                                                                           
 * * * * * * * O O *                                                                                                                           
 * * * * * * * * * *                                                                                                                           
 * * * * * * * * * *                                                                                                                           
 * * * * * * * * * *                                                                                                                           
 * * * * * * * * * *                                                                                                                           
 * * * * * * * * * *                                                                                                                           
 * * * * * * * * * *                                                                                                                           

 * * * * * * * * * *                                                                                                                           
 * * O O * * * * * *                                                                                                                           
 * * * * * * * * * *                                                                                                                           
 * * * * * * * * * *                                                                                                                           
 * * * * * * * * * *                                                                                                                           
 * * * * * * * * * *                                                                                                                           
 * * * * * * * * * *                                                                                                                           
 * * * * * * * * * *                                                                                                                           
 * * * * * * * * * *                                                                                                                           
 * * * * * * * * * *