3

嗨，如果有人可以建议如何正确地做到这一点。基本上，我正在尝试创建一个名为 Board 的类变量，其中包含 ChessPiece 实例的二维数组。

#include <stdio.h>
#include <iostream>
#include <stdlib.h>
using namespace std;

class ChessPiece
{
public:
    char ToChar() { return '#'; };
};

class ChessBoard
{
    int Size;   //This means board is 8x8.
    ChessPiece ** Board;

public:
    ChessBoard();
    int GetSize() { return Size; };

    void PlotBoard();
};

ChessBoard::ChessBoard() {
    Size = 8;
    ChessPiece newBoard[Size][Size];
    Board = newBoard; //Problem here!!! How do I make Board an 8x8 array of ChessPiece?
}

void ChessBoard::PlotBoard() {
    int x, y;
    for (x = 0; x < Size; x++) {
        for (y = 0; y < Size; y++)
            printf("%c", Board[x][y].ToChar());
    }
}

int main()
{
    // ChessBoard board;
    // printf("%d", board.GetSize());
    // board.PlotBoard();

    ChessBoard * a = new ChessBoard();

    return 0;
}

我真的在这里错过了非常基本的东西，但我似乎无法弄清楚。谢谢！

4

5 回答 5

2

在您的场景中确实没有理由使用原始指针。我建议将板保持为一维std::vector，并在迭代板时简单地使用行/列的乘法。

class ChessBoard
{
public:
   ChessBoard(size_t row_count) : Size(row_count), Board(row_count * row_count)
   {
   }

   void PlotBoard()
   {
     for(size_t row = 0; row < Size; ++row)
     {
        for(size_t col = 0; col < Size; ++col)
            printf("%c", Board[(row * Size) + col].ToChar());
     }
   }
}

private:
   size_t Size;
   std::vector<ChessPiece> Board;
};
于 2013-08-13T19:06:15.133 回答
1 
class ChessBoard {
    public:
    enum Field {
       Empty,
       Pawn,
       ...
    };
    const Columns = 8;
    const Rows = 8;
    Field& operator()(unsigned column, unsigned row) { 
        return fields(column * Rows + row);
    } // omitting const/non const and range checks

    private:
    Field fields[Columns * Rows];
};
于 2013-08-13T19:17:39.917 回答
0

去年我做了一个类似的项目。为此，我创建了一个 Square 类，以便 Board 由 Squares 的二维数组组成。我认为通过这种方式你可以更灵活地为 Square 创建方法，例如检查 Square 上是否有 Piece（它自己的类）、什么类型的 Piece 以及添加和删除 Pieces。

我认为您需要以基本的 OO 方式解决问题。

于 2013-08-14T00:34:13.270 回答
0

将您的构造函数更改为：

ChessBoard::ChessBoard():Size(8) {
    Board=new ChessPiece*[Size];

    for (int i=0;i<Size;++i)
        Board[i]=new ChessPiece[Size];
}

您还需要一个析构函数：

ChessBoard::~ChessBoard()
{
    for (int i=0;i<Size;++i)
        delete [] Board[i];

    delete [] Board;
}

如果要允许复制/移动，请务必添加正确的复制/移动构造函数和复制/移动赋值运算符。

于 2013-08-13T18:59:30.597 回答
-1

这里的问题是 newBoard 是使用自动存储持续时间创建的，这意味着当您超出范围时（在 ChessBoard 构造函数的末尾），它将被清除。如果 Size 永远不会改变，您可以将其设置为常量并像这样创建板：

#define SIZE 8
class ChessBoard
{
    ChessPiece Board[SIZE][SIZE];

如果大小可能会改变，您需要像这样在循环中分配数组：

Board = new ChessPiece *[Size];
for (int i = 0; i < Size; i++){
    Board[i] = new ChessPiece[Size];
}
于 2013-08-13T19:17:28.950 回答