Question

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***'

Answer 1

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

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

然后是编译错误。这是因为&board是board的地址。由于board的类型为char**，因此&board的类型为char***。这是编译器所说的。您需要传递board而不是&board。

printBoard(board, dim);

Answer 2

&varname为您提供指向该变量的指针。 &board，其中board为int**，为您提供指向int**的指针;换句话说，和int***。

Answer 3

您已将您的电路板空间定义为char类型，但是当您的需求发生变化时会发生什么？您应该提供struct或typedef，如果您的需求/需求发生变化，那么更改会更容易。

typedef char boardspace;

您可以只分配单个数组，维度rowsize x columsize，然后使用forumla通过计算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);

}

预期'char '但参数类型为'char *'

3 个答案:

预期'char **'但参数类型为'char ***'

3 个答案:

预期'char '但参数类型为'char *'