C++：如何为多个子类参数重载Board类的move_piece方法？

我正在开发象棋程序以练习基础OOP，现有抽象基类Piece，以及King、Rook、Pawn等子类，还有Board类。我希望在Board类中创建多个重载的move_piece函数，根据参数的子类执行不同操作，代码结构如下：

class Piece {};

class King : public Piece {};

class Rook: public Piece {};

class Pawn: public Piece {};

class Board {
public:
  void move_piece(King piece) {
    ;
  }

  void move_piece(Rook piece) {
    ;
  }

  void move_piece(Pawn piece) {
    ;
  }
};

int main() {
  Board game;
  Pawn pawn;
  Piece p = pawn;
  game.move_piece(p);
}

但当我传入声明为Piece类型的对象时，出现错误：

no suitable user-defined conversion from "Piece" to "Pawn" exists

请问能否实现我想要的功能？

解决方案 #

你当前的写法存在两个核心问题：

1. 对象切片：Piece p = pawn;会把Pawn对象切片为Piece基类对象，丢失所有子类特有的类型和数据，此时p只是一个纯粹的Piece实例，无法还原为子类。
2. 静态重载解析：C++的函数重载是编译期确定的，编译器只会根据参数的静态类型（这里p的静态类型是Piece）匹配重载函数，但你的Board类没有接受Piece参数的move_piece，因此编译报错。

以下是两种可行的实现方式：

方式一：使用多态（推荐，符合OOP设计） #

让Piece类定义纯虚的移动方法，子类各自实现自身的移动逻辑，Board只需提供一个接受Piece指针/引用的统一方法：

#include <memory>

// 抽象基类，包含纯虚move方法和虚析构
class Piece {
public:
    virtual void move(class Board& board) = 0;
    virtual ~Piece() = default;
};

class King : public Piece {
public:
    void move(Board& board) override {
        // 实现国王的移动逻辑
    }
};

class Rook : public Piece {
public:
    void move(Board& board) override {
        // 实现车的移动逻辑
    }
};

class Pawn : public Piece {
public:
    void move(Board& board) override {
        // 实现兵的移动逻辑
    }
};

class Board {
public:
    // 使用指针传递，避免切片
    void move_piece(Piece* piece) {
        if (piece) {
            piece->move(*this); // 动态调用对应子类的move方法
        }
    }

    // 使用智能指针更安全，避免内存泄漏
    void move_piece(std::unique_ptr<Piece>& piece) {
        if (piece) {
            piece->move(*this);
        }
    }
};

int main() {
    Board game;
    std::unique_ptr<Piece> pawn = std::make_unique<Pawn>();
    game.move_piece(pawn); // 正确调用Pawn的移动逻辑

    King* king = new King();
    game.move_piece(king);
    delete king;
}

方式二：使用访问者模式（将移动逻辑保留在Board中） #

如果坚持把移动逻辑放在Board类而非子类里，可以用访问者模式实现动态类型分发：

class Board;

// 访问者接口，定义对各子类的处理方法
class PieceVisitor {
public:
    virtual void visit(King& king, Board& board) = 0;
    virtual void visit(Rook& rook, Board& board) = 0;
    virtual void visit(Pawn& pawn, Board& board) = 0;
    virtual ~PieceVisitor() = default;
};

class Piece {
public:
    virtual void accept(PieceVisitor& visitor, Board& board) = 0;
    virtual ~Piece() = default;
};

class King : public Piece {
public:
    void accept(PieceVisitor& visitor, Board& board) override {
        visitor.visit(*this, board);
    }
};

class Rook : public Piece {
public:
    void accept(PieceVisitor& visitor, Board& board) override {
        visitor.visit(*this, board);
    }
};

class Pawn : public Piece {
public:
    void accept(PieceVisitor& visitor, Board& board) override {
        visitor.visit(*this, board);
    }
};

class Board {
public:
    // 嵌套访问者类，实现各棋子的移动逻辑
    class MoveVisitor : public PieceVisitor {
    public:
        void visit(King& king, Board& board) override {
            // 国王的移动逻辑
        }

        void visit(Rook& rook, Board& board) override {
            // 车的移动逻辑
        }

        void visit(Pawn& pawn, Board& board) override {
            // 兵的移动逻辑
        }
    };

    void move_piece(Piece* piece) {
        if (piece) {
            MoveVisitor visitor;
            piece->accept(visitor, *this);
        }
    }
};

int main() {
    Board game;
    Pawn pawn;
    Piece* p = &pawn; // 用指针避免切片
    game.move_piece(p); // 正确调用Pawn对应的移动逻辑
}

关键注意点 #

• 必须使用指针或引用传递Piece对象，避免对象切片，才能保留子类的类型信息。
• 基类Piece必须声明虚析构函数，否则通过基类指针删除子类对象会导致未定义行为。

内容的提问来源于stack exchange，提问作者BENJAMIN GILBERT