0 
void printboard (char **board, int n)

在我的主要功能中，我使用创建了二维数组

char **board;
board = malloc(dim);
for (i = 0; i < dim; i++)
{
    board[i] = malloc(dim);
}

在我的数组中输入字符后，我使用了

printBoard(&board, dim);

在编译时，我得到了错误

note: expected 'char **' but argument is of type 'char***'
4

3 回答 3

3

你的第一个 malloc 不好。您想为dim类型的指针分配空间char*。所以你需要：

board = malloc(dim*sizeof(char*));

然后是编译错误。那是因为&board是 的地址board。既然board有类型char**，那么&board就有类型char***。这是编译器所说的。您需要通过board而不是&board.

printBoard(board, dim);
于 2013-11-08T21:26:34.480 回答
0

&varname给你一个指向那个变量的指针。&board，其中 board 是一个int**，给你一个指向 an 的指针int**；换句话说，和int***。

于 2013-11-08T21:27:15.043 回答
0

您已将板空间定义为 char 类型，但是当您的需求发生变化时会发生什么？如果您的需求/要求发生变化，您可能应该提供一个结构或 typedef，然后更改会更容易一些。

typedef char boardspace;

您可以只分配一个维度为 rowsize x columsize 的数组，然后使用论坛通过计算 position = row*columsize+column 来找到棋盘位置，

boardspace* BoardNew(int dim)
{
    int i;
    if (dim<4) dim=4;
    //allocate as single array, dim x dim
    boardspace* newboard = malloc(sizeof(boardspace)*dim*dim);
    return newboard;
}
void BoardPrint (boardspace* board, int dimension);

使用这种方法，您可以使用公式/函数将位置对（行、列）转换为数组位置，

int boardposition(int dim, int row, int col)
{
    return row*dim + col;
}

或者，您可以分配一个行数组，每行包含一个指向列数组的指针。但这意味着你需要检查多个malloc的结果，并且错误处理变得更加困难，

//or,
boardspace** BoardNew(int dim)
{
    int i;
    int error=0;
    //allocate as array of rows of pointers to columns
    boardspace** rows = malloc(sizeof(boardspace*)*dim);
    for (i = 0; i < dim; i++)
    {
        if( !( rows[i] = malloc(sizeof(boardspace))) ) error++;
    }
    if( error ) {
        for (i = 0; i < dim; i++)
        {
            free(rows[i]);
        }
        free(rows);
    }
    return rows;
}
void BoardPrint (boardspace** board, int dimension);

上述选择驱动其他一切。

您可能会认识到，您可能需要的不仅仅是一个字符用于板位置（可能是内容列表和许多其他内容）。在这里，您对于一维和二维板分配有相同的选择，但您还有一个板包含结构，它可以存储板和尺寸。

typedef struct space_s
{
    char space;
} SpaceObj;
typedef struct board_s
{
    int dim;
    SpaceObj* board;
} BoardObj;

使用前面提到的棋盘位置公式，在一维中分配棋盘，

BoardObj* BoardNew(int dim)
{
    if (dim<4) dim=4;
    BoardObj* bp = malloc(sizeof(BoardObj));
    if(!bp) return NULL;
    bp->dim = dim;
    SpaceObj* sp = malloc(sizeof(SpaceObj)*dim*dim);
    if(!bp) { free(bp); return NULL; }
    return sp;
}
void BoardPrint (BoardObj* board);

请注意，通过在板结构中存储维度，您不必携带该值，

int boardposition(BoardObj* board, int row, int col)
{
    return row*(board->dim) + col;
}

或者您可以使用二维方法，但是对于板结构，

//or,
typedef struct board_s
{
    int dim;
    SpaceObj** rows;
} BoardObj;
BoardObj* BoardNew(int dim)
{
    int i;
    int error=0;
    if (dim<4) dim=4;
    BoardObj* bp = malloc(sizeof(BoardObj));
    if(!bp) return NULL;
    bp->dim = dim;
    SpaceObj** rows;
    if( !(rows = malloc(sizeof(SpaceObj*)*dim)) ) { free(bp); return NULL; }
    bp->rows = rows;
    for (i = 0; i < dim; i++)
    {
        bp->rows[i] = rows[i] = malloc(dim);
    }
    if(error) {
        for (i = 0; i < dim; i++)
        {
            free(rows[i]);
        }
        free(rows);
        free(bp);
    }
    return bp;
}
void BoardPrint (BoardObj* board);

你需要以不同的方式分配和传递你的板子，在这里他们被说明了，

main()
{
    int dim = 8;
    //and then you have one of these to manipulate,
    boardspace* board = BoardNew(dim);
    boardspace** board = BoardNew(dim);
    BoardObj* board = BoardNew(dim);
    BoardObj* board = BoardNew(dim);

    //which can be addressed in the appropriate way,
    BoardPrint(board, dim);
    BoardPrint(board, dim);
    BoardPrint(board);
    BoardPrint(board);

}
于 2013-11-08T22:28:23.683 回答