C++ C+中的抽象/基本结构+；？

我在下国际象棋，我想要一组棋子

如果我是正确的，在Java中，您可以有一个抽象的

片段

类，并让

国王

或

女王

扩展该类。如果我要制作一个

Piece

s数组，我可以将

King

块放置在数组中的某个位置，将

Queen

块放置在另一个位置，因为

King

和

Queen

都扩展了

Piece

---

<> P>是否有任何方法可以在C++中使用结构？

< P>你可以通过在类中添加纯虚函数来模拟C++中的<强> <强>。p> 在C++中，你可以用你在课堂上所能使用的结构来做任何事情。 C++中的结构仅在成员的默认访问规范和继承期间与类不同。p> 是的。你可以在C++中创建一个。只需将一个或多个方法设置为纯虚拟：

class Piece {
    public:
        Piece ();
        virtual ~Piece ();
        virtual void SomeMethod () = 0;  // This method is not implemented in the base class, making it a pure virtual method. Subclasses must implement it
 };

然后可以创建实现纯虚拟方法的子类

class King : public Piece {
    // ... the rest of the class definition
    virtual void SomeMethod (); // You need to actually implement this
};

---

<>你可以在C++中使用继承，就像你在爪哇使用的一样。C++既有类又有结构，在这种情况下，你也可以使用. < C++中的抽象类只是纯虚拟方法的类。这些方法没有方法定义

您的解决方案可能如下所示：

class Piece {
public:
   virtual ~Piece ();
   virtual void move() = 0; //this is a pure virtual function, making this an abstract class.
};

class King : public Piece {
public:
   void move() {};
};

class Queen : public Piece {
public:
  void move() {};
};

....

Piece *myPieces[2] = new Piece*[2];
myPieces[0] = new King();
myPieces[1] = new Queen(); 

当然

然后后来,

AbstractPiece* array[size];

及

---

<>强> C++中可以使用抽象类或结构：< /强>

#include <iostream>
#include <vector>
#include <algorithm>
#include <boost/lambda/bind.hpp>
#include <boost/lambda/lambda.hpp>
#include <boost/lambda/construct.hpp>

using namespace std;

struct piece
{
    virtual ~piece() {};
    virtual void dosomething() = 0;
};

struct king : piece
{
    ~king() { cout << __PRETTY_FUNCTION__ << endl; }
    void dosomething() { cout << __PRETTY_FUNCTION__ << endl; }
};

struct queen : piece
{
    ~queen() { cout << __PRETTY_FUNCTION__ << endl; }
    void dosomething() { cout <<  __PRETTY_FUNCTION__ << endl; }
};

struct pawn : piece
{
    ~pawn() { cout << __PRETTY_FUNCTION__ << endl; }
    void dosomething() { cout << __PRETTY_FUNCTION__ << endl; }
};

---

我宁愿避免使用指针，因为你必须记得清理它们

此设计使用策略模式。该界面为

PieceType

，可用于显示板上的有效位置，或显示板上的初始位置。我相信，您希望每种战略都能做到更多：

class Board;

class PieceType
{
public:
    virtual showValidMoves(Board& board) const = 0;
    virtual showInitialPosition(Board& board) const = 0;
    // ...  
};

class Pawn : public PieceType
{
public:
    virtual showValidMoves(Board& board) const;
    virtual showInitialPosition(Board& board) const;
    // ...
};

class Rook : public PieceType
{
    // ...
};
//...

我们只需要每个

片段类型中的一个
，由于该类型在棋子之间共享，因此它也可以是常量：

const Pawn PAWN;
const Rook ROOK;
const Knight KNIGHT;

我们使用这些策略初始化向量中的棋子：

class ChessMan
{
public:
    enum Colour {Black, White};

    ChessMan(const Colour& colour, PieceType& pieceType);

    void showValidMoves(Board& board);
    void showInitialPosition(Board& board);
private:
    Colour m_colour;
    PieceType& m_pieceType;
};

我将总结将
棋子添加到向量自身函数中的代码：

void add(vector<ChessMan>& chessmen,
         const ChessMan::Colour& colour,
         const PieceType& pieceType,
         const unsigned int amount)
{
    chessmen.insert(chessmen.end(), ChessMan(colour, pieceType), amount);
}

void main()
{
    using std::vector;

    vector<ChessMan> chessmen;
    add(chessmen, 16, ChessMan::Black, PAWN);
    add(chessmen, 2, ChessMan::Black, ROOK);
    add(chessmen, 2, ChessMan::Black, KNIGHT);
    //...
}

void add（向量和棋子），
恒棋人：颜色和颜色，
常量PieceType和PieceType，
常量（无符号整数金额）
{
棋子.insert（chessmen.end（）、棋子（颜色、棋子类型）、金额）；
}
void main（）
{
使用std：：vector；
矢量棋子；
添加（棋子，16，棋子：：黑色，棋子）；
添加（棋子，2，棋子：：黑色，车）；
添加（棋子，2，棋子：：黑色，骑士）；
//...
}

好机会结构> /COD>和类< /C>几乎是相同的。有一个很好的讨论，它们不是有效的C++类语法。您不需要在
类
关键字前面预先添加访问说明符。通过将k和q分配给myPieces，您也会有潜在的拼接问题。对不起，我对代码进行了一些编辑。你说的拼接问题是什么意思？谢谢。我再次编辑了代码。希望这看起来更好。我想你指的是切片，而不是Splicing你缺少了一个虚拟析构函数。这是一个非常复杂的问题的答案！你真的需要介绍
\uuu PRETTY\u FUNCTION\uuu
、boost、lambdas、标准算法等吗？@LucTouraille我习惯于使用
\uu PRETTY\u FUNCTION\uuu
，因为它显示类名和参数类型/返回值。这样就很容易看到被称为什么。至于剩下的，我真的不想花更多的时间来得到一个简单的答案，所以我使用了我首先想到的方法——当然我可以花更多的时间打字，让答案更长……你缺少了一个虚拟析构函数。问题是关于抽象基类，而不是关于象棋游戏的最佳设计。尽管你的回答可能会引起原始海报的兴趣，但它根本没有解决这个问题。@LucTouraille我认为使用容器处理同质数据很重要。异构行为最好存储在其他地方。所以我把指向抽象类的指针放在同构对象中。我认为这是一个好原则。如果示例太长，或者看起来像是我提供了一个完整的解决方案，我很抱歉。你可以自由地编辑它，让它变得更好。
class Board;

class PieceType
{
public:
    virtual showValidMoves(Board& board) const = 0;
    virtual showInitialPosition(Board& board) const = 0;
    // ...  
};

class Pawn : public PieceType
{
public:
    virtual showValidMoves(Board& board) const;
    virtual showInitialPosition(Board& board) const;
    // ...
};

class Rook : public PieceType
{
    // ...
};
//...

const Pawn PAWN;
const Rook ROOK;
const Knight KNIGHT;

class ChessMan
{
public:
    enum Colour {Black, White};

    ChessMan(const Colour& colour, PieceType& pieceType);

    void showValidMoves(Board& board);
    void showInitialPosition(Board& board);
private:
    Colour m_colour;
    PieceType& m_pieceType;
};

void add(vector<ChessMan>& chessmen,
         const ChessMan::Colour& colour,
         const PieceType& pieceType,
         const unsigned int amount)
{
    chessmen.insert(chessmen.end(), ChessMan(colour, pieceType), amount);
}

void main()
{
    using std::vector;

    vector<ChessMan> chessmen;
    add(chessmen, 16, ChessMan::Black, PAWN);
    add(chessmen, 2, ChessMan::Black, ROOK);
    add(chessmen, 2, ChessMan::Black, KNIGHT);
    //...
}