棋子层次结构设计：继承与类型字段

Question

我有一个片段的基类

 class piece;

和一个包含派生对象的数组

piece* board[8][8];

优点，通过虚拟函数进行干净的设计。缺点是，如果我必须在板上找到一块或比较一块，我必须恢复到动态铸造（或 typeid）。它很丑陋，并且在发出数百万个请求时可能会消耗性能。

另一方面，如果我创建一个单件类的数组，它有一个用于识别件的类型字段，我就不会遇到这个问题（而且它应该更快），但我必须制作超级丑陋的 switch 语句。我想，由于部件的数量是有限的，而且我不认为自己会做那么多的开关，所以这最终可能是一个更好的选择，你觉得呢？

这是为了好玩（所以没有位板）。

阅读一些答案，我认为仅使用类型字段进行运算符重载（==，！=，...）可以带来两个词的最佳效果。

boost::variant 看起来也很有趣。

Answer 1

或者，如果您的类集有限 - 即您知道数量，请使用变体和访问者。例如， boost::variant 而棋盘就是由这种类型的 2D 数组组成的。现在要进行询问，您可以使用访客...

Answer 2

我会选择类层次结构。

为了查找作品，您可以为每种作品类型保留一个单独的列表。这样您就知道在哪里寻找每种单品类型。

为了进行比较，您也可以依赖虚拟方法。

另一种方法是使用组件架构（如下所述：http://cowboyprogramming .com/2007/01/05/evolve-your-heirachy/），但我认为这对于一个你清楚地知道类型并且知道这些类型不会很快改变的国际象棋游戏来说太多了:)。

Answer 3

我会使用层次结构，如果我想知道类型（为什么？）有一个标识类型的虚拟方法。

Answer 4

我从来没有写过国际象棋程序，但我猜最常见的操作是这样的：

• 显示/打印棋盘
• 获取每个棋子的可能移动集
• 总结棋盘所有棋子的值，也许总结一些取决于棋子的“位置值”（车在开放线上，诸如此类）

此外，某些棋子具有“状态”（国王只能在之前没有移动过的情况下才能城堡，兵可以攻击顺便说一下，如果另一个棋子刚刚移动了两个方格），则仅适用于一种棋子。

这一切都让我尖叫着阶级等级制度。 （假设您不需要位板性能）

另一方面，您不太可能需要添加新的块类型，或者您将能够单独重复使用其中一个块类型。即可扩展性和模块化并不是真正的问题。因此，如果您发现算法的某些重要部分实际上应该位于一个位置，但分散在多个片段类中 - 请使用 switch 语句。只需在返回 PieceType 枚举的 Piece 类中添加一个抽象方法并打开它即可。

Answer 5

您不能同时担心性能和代码的乐趣:)

考虑使用“半字节板”（或至少是字节板）而不是位板，其中每个半字节代表一种类型。每个半字节也是在该块类型上操作的单例对象表中的索引。

class Empty : public Piece {};
class Rook : public Piece {};
...

const int wrook = 1;
...
const int bpawn = 12;

Piece* Operator[13] = {new Empty(), new Rook(), ..., new Pawn()};

byte table[64] = {
    wrook, wbishop, wknight, wking, wqueen, wknight, wbishop, wrook,
    wpawn, wpawn, wpawn, wpawn, wpawn, wpawn, wpawn, wpawn, 
    0, 0, 0, 0, 0, 0, 0, 0, 
    0, 0, 0, 0, 0, 0, 0, 0, 
    0, 0, 0, 0, 0, 0, 0, 0, 
    0, 0, 0, 0, 0, 0, 0, 0, 
    bpawn, bpawn, bpawn, bpawn, bpawn, bpawn, bpawn, bpawn, 
    brook, bbishop, bknight, bking, bqueen, bknight, bbishop, brook};

// Given some position and some operation DoSomething we would have this:
Operator[table[position]]->DoSomething(table, position, <other parameters>);

// Possible return value of DoSomething might be new table

Answer 6

“超级难看的 switch 语句”是正确的技术。它并不难看。这就是所谓的函数式编程。

继承是完全错误的技术。每个棋子都以不同的方式移动，具有不同的图形和其他属性。没有什么共同点。棋子并不是抽象的。它们是离散对象的具体集合。

你必须通过统一来使一些东西变得通用：创建所谓的求和类型。
在 Ocaml 中：

type shape = Pawn | Rook | Knight | Bishop | Queen | King
type color = Black | White
type piece = shape * color
type pos = { row:int;  col:int }

let check_white_move piece board from to = match piece with
| Pawn -> on_board to && (from.row = 2 && to.row = 4 or to.row = from.row + 1)
| ....

在 C++ 中没有正确的求和类型，您可以使用它来代替：

enum shape { pawn, rook, knight, bishop, queen, king};
..
bool check_white_move (..) { switch piece {
 case pawn: ...

它更笨拙。向 C 和 C++ 委员会投诉。但要使用正确的概念。总和类型（可区分联合、变体）是统一一组离散的具体类型的方式。类和继承用于表示抽象并提供其实现。

国际象棋没有什么抽象的。这都是关于组合的。这不是不同技术的优缺点的问题：而是使用正确的技术的问题。

[顺便说一句：是的，你可以尝试 boost 变体，但我不能推荐它用于此应用程序，因为这些片段没有关联数据，枚举是完美的]