C++ c++；静态成员函数

我的作业有问题

这项作业是关于国际英语国际象棋的

需要执行以下任务之一来实现静态成员函数，该函数在给定匹配的PieceChar和位置的情况下返回国际象棋对象的适当部分

我建议它应该使用类似于克隆函数的成员函数来实现工厂成员函数，但不要使用克隆成员函数本身。这家工厂应该同样高效 尽可能地，因此代码是无效的（例如，在多分支方面）

这是给定的片段

enum class PieceChar : char
{
    WHITE_PAWN = 'P',
    WHITE_KNIGHT = 'N',
    WHITE_BISHOP = 'B',
    WHITE_ROOK = 'R',
    WHITE_QUEEN = 'Q',
    WHITE_KING = 'K',

    BLACK_PAWN = 'p',
    BLACK_KNIGHT = 'n',
    BLACK_BISHOP = 'b',
    BLACK_ROOK = 'r',
    BLACK_QUEEN = 'q',
    BLACK_KING = 'k',
    EMPTY = 'e',
};

这里是一些棋子传承基础的骨架

 class Piece
{
public:
  Piece(Colour c, const Position& pos);
  virtual void GenMoves(const Board &, std::vector<Move>& ) const = 0;
  Colour colour() const;
  void position(const Position& pos);
  const Position& position() const;
  virtual Piece* Clone() const = 0;
  static Piece* Factory(PieceChar, const Position& pos);
  virtual ~Piece();
private:
  Colour piece_colour;
  Position piece_pos;
};

class Pawn: public Piece
{
public:
  Pawn(Colour c, const Position& pos);
  ~Pawn();
  void GenMoves(const Board &, std::vector<Move>& ) const override;
  Piece* Clone() const override;
};

如果有任何关于这个问题的提示或指南，我不知道我可以在哪里问这个问题

如果您需要更多信息，请随时询问

---

加载项：我无法修改给定的声明，但我只能允许添加更多帮助程序功能。简单开关执行以下操作：

static std::unique_ptr<Piece> Piece::Factory(PieceChar type, const Position& pos)
{
    switch (type) {
        case PieceChar::WHITE_PAWN: return std::make_unique<Pawn>(Colour::White, pos);
        case PieceChar::WHITE_KNIGHT: return std::make_unique<Knight>(Colour::White, pos);
        case PieceChar::WHITE_BISHOP: return std::make_unique<Bishop>(Colour::White, pos);
        case PieceChar::WHITE_ROOK: return std::make_unique<Rook>(Colour::White, pos);
        case PieceChar::WHITE_QUEEN: return std::make_unique<Queen>(Colour::White, pos);
        case PieceChar::WHITE_KING: return std::make_unique<King>(Colour::White, pos);

        case PieceChar::BLACK_PAWN: return std::make_unique<Pawn>(Colour::Black, pos);
        case PieceChar::BLACK_KNIGHT: return std::make_unique<Knight>(Colour::Black, pos);
        case PieceChar::BLACK_BISHOP: return std::make_unique<Bishop>(Colour::Black, pos);
        case PieceChar::BLACK_ROOK: return std::make_unique<Rook>(Colour::Black, pos);
        case PieceChar::BLACK_QUEEN: return std::make_unique<Queen>(Colour::Black, pos);
        case PieceChar::BLACK_KING: return std::make_unique<King>(Colour::Black, pos);
        case PieceChar::EMPTY: throw std::runtime_error("invalid type");
    }
    throw std::runtime_error("unknown type");
}

static std:：unique\u ptr Piece:：Factory（PieceChar类型、const位置和位置）
{
开关（类型）{
case PieceChar:：WHITE_PAWN:返回标准：：使_唯一（颜色：：白色，位置）；
案例PieceChar:：WHITE_KNIGHT:return std:：make_unique（颜色：：白色，位置）；
案例PieceChar:：WHITE\u BISHOP:return std:：make\u unique（颜色：：白色，位置）；
case piecchar:：WHITE\u ROOK:return std:：make\u unique（颜色：：白色，位置）；
case PieceChar:：WHITE_QUEEN:return std:：make_unique（颜色：：白色，位置）；
case piecchar:：WHITE\u KING:return std:：make\u unique（颜色：：白色，位置）；
case PieceChar:：BLACK_PAWN:返回标准：：使_唯一（颜色：：黑色，位置）；
案例PieceChar:：BLACK_KNIGHT:返回标准：：使_唯一（颜色：：黑色，位置）；
案例PieceChar:：BLACK\u BISHOP:return std:：make\u unique（颜色：：黑色，位置）；
案例PieceChar:：BLACK\u ROOK:return std:：make\u unique（颜色：：黑色，位置）；
case PieceChar:：BLACK_QUEEN:返回标准：：使_唯一（颜色：：黑色，位置）；
case PieceChar:：BLACK\u KING:return std:：make\u unique（颜色：：黑色，位置）；
case PieceChar:：EMPTY:throw std:：runtime_错误（“无效类型”）；
}
抛出std:：runtime_错误（“未知类型”）；
}

不要返回

工件*

，返回

std:：shared\u ptr

欢迎使用堆栈溢出。“我卡住了”不是问题。请制定一份属于StackOverflow范围的问题陈述。我们不是来做你的家庭作业的；）你可能要寻找的是“C++类中的静态函数是什么？”你好，谢谢你的解决方案，我忘了再加1点，我不能修改函数的给定声明，现在我猜它会引起内存泄漏，如果我返回新的典当（颜色：：白色，POS）；相反，对于给定的签名，所有权是明确的，若您返回原始指针，则必须手动对其调用delete。

static std::unique_ptr<Piece> Piece::Factory(PieceChar type, const Position& pos)
{
    switch (type) {
        case PieceChar::WHITE_PAWN: return std::make_unique<Pawn>(Colour::White, pos);
        case PieceChar::WHITE_KNIGHT: return std::make_unique<Knight>(Colour::White, pos);
        case PieceChar::WHITE_BISHOP: return std::make_unique<Bishop>(Colour::White, pos);
        case PieceChar::WHITE_ROOK: return std::make_unique<Rook>(Colour::White, pos);
        case PieceChar::WHITE_QUEEN: return std::make_unique<Queen>(Colour::White, pos);
        case PieceChar::WHITE_KING: return std::make_unique<King>(Colour::White, pos);

        case PieceChar::BLACK_PAWN: return std::make_unique<Pawn>(Colour::Black, pos);
        case PieceChar::BLACK_KNIGHT: return std::make_unique<Knight>(Colour::Black, pos);
        case PieceChar::BLACK_BISHOP: return std::make_unique<Bishop>(Colour::Black, pos);
        case PieceChar::BLACK_ROOK: return std::make_unique<Rook>(Colour::Black, pos);
        case PieceChar::BLACK_QUEEN: return std::make_unique<Queen>(Colour::Black, pos);
        case PieceChar::BLACK_KING: return std::make_unique<King>(Colour::Black, pos);
        case PieceChar::EMPTY: throw std::runtime_error("invalid type");
    }
    throw std::runtime_error("unknown type");
}