从0开始写中国象棋-走一步棋（当门炮，马来跳）（C++）

已于 2023-10-04 11:04:05 修改
阅读量848 收藏 7
点赞数 2
分类专栏： Qt CMake C++ 中国象棋程序实现 文章标签： c++
于 2023-10-02 10:27:42 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/calmreason/article/details/133485065
版权

在文章 从0开始写中国象棋-创建棋盘与棋子

中，我们已经可以看到象棋游戏的界面了。

这是因为，我们创建了棋盘（棋盘数组），并在棋盘上放置一些数字来表示棋子。

让棋子动起来

现在，我们打算让棋子动起来。

棋子动起来，其实很简单，比如开局 炮二平五。

实际上就是棋子从棋盘上的一个位置移动到了棋盘的另一个位置。

实际上是棋盘在变化

对应棋盘的变化就是，棋盘从：

变成了：

由于棋盘上的棋子就是一个一个的不同的数字，所以，从计算机的角度来说，走一步棋就是给二维数组的一个位置设置一个新数字。

也就是，起点位置元素重新赋值为0（表示这里没有棋子了，棋子走到其他位置去了）；

终点位置元素重新赋值为炮的ID（表示炮走棋来到了这里）。

程序实现 GoAhead(OneStep)

现在我们希望告诉程序，走一步棋，从一个位置走到另一个位置，程序就能够实现这个目标。

由于这种需求是在下棋双方走棋的时候反复出现的，所以我们可以很方便的用函数来实现。

这个函数大概像下面这样：

bool GoAhead(from_row, from_col, to_row, to_col);

其中，各个参数的意思是很明显的，我们就不解释了。

但是，函数返回值是bool，这个是干什么的呢？

因为用户可能会乱走棋，比如，蹩马腿了也要跳马，这个时候你就要告诉他不能走这步棋。这时候函数返回 false 。

现在让我们来实现这个函数：

bool GoAhead(int from_row, int from_col, int to_row, int to_col)
{
    //如果出发的地方没有旗子，就返回 false
    if()
}

这个时候我们才发现我们需要访问棋盘。

而棋盘是定义在main函数内的变量。我们访问不到。

怎么办？

C++全局变量

不在函数内定义的变量就叫全局变量。

为了能够让任何代码都访问到棋盘，我们在程序的一开始就定义棋盘。这样我们的函数就可以访问棋盘了。

//棋盘数组，不同的数字表示不同的棋子，0表示没有棋子
vector<vector<int>> chess_board
{
    { 1, 2, 3, 4, 5, 6, 7, 8, 9},
    { 0, 0, 0, 0, 0, 0, 0, 0, 0},
    { 0,10, 0, 0, 0, 0, 0,11, 0},
    {12, 0,13, 0,14, 0,15, 0,16},
    { 0, 0, 0, 0, 0, 0, 0, 0, 0},
    { 0, 0, 0, 0, 0, 0, 0, 0, 0},
    {26, 0,27, 0,28, 0,29, 0,30},
    { 0,31, 0, 0, 0, 0, 0,32, 0},
    { 0, 0, 0, 0, 0, 0, 0, 0, 0},
    {17,18,19,20,21,22,23,24,25},
};

bool GoAhead(int from_row, int from_col, int to_row, int to_col)
{
    //如果出发的地方没有旗子，就返回 false
    if (chess_board[from_row][from_col] != 0)
    {

    }
    else
    {
        return false;
    }
}

谁能告诉我能否走到哪里？

现在的问题是，当走棋的起点有棋子的时候，这个棋子能否到达目的地位置？

也就是走棋的合理性问题。

这里门道就多了：马走日，相走田，车走直路，炮翻山，小卒一去不会还。

如何实现这样的需求呢？

C++的方式是使用多态来实现。伪代码像下面这样：

//棋子类的基类
struct chess_base
{
    // 纯虚函数，表示 chess_base 是一个抽象类，专门用来做基类；
    //GoAhead 用来给各个派生类来重新实现 override
    virtual bool GoAhead(int from_row, int from_col, int to_row, int to_col) = 0;
};

struct Horse : public chess_base
{
    // 马实现自己的走棋
    bool GoAhead(int from_row, int from_col, int to_row, int to_col)
    {
        //ba la ba la ....
        return false;
    }
};

struct King : public chess_base
{
    // 帅实现自己的走棋
    bool GoAhead(int from_row, int from_col, int to_row, int to_col)
    {
        //ba la ba la ....
        return false;
    }
};

每个棋子都知道自己的规则，所以自己是知道能否走到目的地的。

这也就要求我们要替各个棋子来实现它们各自的走法。

棋子数组包含对象

之前，我们的棋子数组是不同位置（数组下标）表示不同棋子，棋子只有一个内容，就是它们的名字。

现在，我们希望用类对象来表示。名字只是棋子的一个成员变量。走棋GoAhead才是棋子的主要能力。

#include <iostream>
#include <string>
#include <vector>
#include <iomanip>
using namespace std;
 
//棋盘数组，不同的数字表示不同的棋子，0表示没有棋子
vector<vector<int>> chess_board
{
    { 1, 2, 3, 4, 5, 6, 7, 8, 9},
    { 0, 0, 0, 0, 0, 0, 0, 0, 0},
    { 0,10, 0, 0, 0, 0, 0,11, 0},
    {12, 0,13, 0,14, 0,15, 0,16},
    { 0, 0, 0, 0, 0, 0, 0, 0, 0},
    { 0, 0, 0, 0, 0, 0, 0, 0, 0},
    {26, 0,27, 0,28, 0,29, 0,30},
    { 0,31, 0, 0, 0, 0, 0,32, 0},
    { 0, 0, 0, 0, 0, 0, 0, 0, 0},
    {17,18,19,20,21,22,23,24,25},
};

//棋子类的基类
struct chess_base
{
    chess_base(const string& name1):name(name1){}
    // 纯虚函数，表示 chess_base 是一个抽象类，专门用来做基类；
    //GoAhead 用来给各个派生类来重新实现 override
    virtual bool GoAhead(int from_row, int from_col, int to_row, int to_col) = 0;
    string name;//棋子要显示的名字
};
//车 車
struct Chariot : public chess_base
{
    Chariot(const string& name1) :chess_base(name1) {}
    // 马实现自己的走棋
    bool GoAhead(int from_row, int from_col, int to_row, int to_col)
    {
        cout << from_row << "," << from_col << "," << to_row << "," << to_col << endl;
        //ba la ba la ....
        return false;
    }
};
//马 馬
struct Horse : public chess_base
{
    Horse(const string& name1):chess_base(name1){}
    // 马实现自己的走棋
    bool GoAhead(int from_row, int from_col, int to_row, int to_col)
    {
        cout << from_row << "," << from_col << "," << to_row << "," << to_col << endl;
        //ba la ba la ....
        return false;
    }
};
//炮 砲
struct Cannon : public chess_base
{
    Cannon(const string& name1) :chess_base(name1) {}
    // 马实现自己的走棋
    bool GoAhead(int from_row, int from_col, int to_row, int to_col)
    {
        cout << from_row << "," << from_col << "," << to_row << "," << to_col << endl;
        //ba la ba la ....
        return false;
    }
};
//将 帅
struct King : public chess_base
{
    King(const string& name1) :chess_base(name1) {}
    // 帅实现自己的走棋
    bool GoAhead(int from_row, int from_col, int to_row, int to_col)
    {
        //ba la ba la ....
        cout << from_row << "," << from_col << "," << to_row << "," << to_col << endl;
        return false;
    }
};
//士 仕
struct Official : public chess_base
{
    Official(const string& name1) :chess_base(name1) {}
    // 帅实现自己的走棋
    bool GoAhead(int from_row, int from_col, int to_row, int to_col)
    {
        //ba la ba la ....
        cout << from_row << "," << from_col << "," << to_row << "," << to_col << endl;
        return false;
    }
};
//相 象
struct Minister : public chess_base
{
    Minister(const string& name1) :chess_base(name1) {}
    // 帅实现自己的走棋
    bool GoAhead(int from_row, int from_col, int to_row, int to_col)
    {
        //ba la ba la ....
        cout << from_row << "," << from_col << "," << to_row << "," << to_col << endl;
        return false;
    }
};
//兵 卒
struct Soldier : public chess_base
{
    Soldier(const string& name1) :chess_base(name1) {}
    // 帅实现自己的走棋
    bool GoAhead(int from_row, int from_col, int to_row, int to_col)
    {
        //ba la ba la ....
        cout << from_row << "," << from_col << "," << to_row << "," << to_col << endl;
        return false;
    }
};

vector<chess_base*> chess_man
{
    nullptr,//下标为0不用，编号从1开始
    //上方黑方棋子
    new Chariot("车"),new Horse("马"), new Minister("相"), new Official("士"), new King("将"), new Official("士"), new Minister("相"), new Horse("马"), new Chariot("车"),

    new Cannon("炮"),new Cannon("炮"),

    new Soldier("兵"), new Soldier("兵"), new Soldier("兵"), new Soldier("兵"), new Soldier("兵"),

    //下方红方棋子
    new Chariot("車"), new Horse("馬"), new Minister("象"), new Official("仕"), new King("帥"), new Official("仕"), new Minister("象"), new Horse("馬"), new Chariot("車"),

    new Soldier("卒"), new Soldier("卒"), new Soldier("卒"), new Soldier("卒"), new Soldier("卒"),

    new Cannon("砲"), new Cannon("砲"),
};


int main(void)
{
    for (int row = 0; row < 10; row++)
    {
        for (int col = 0; col < 9; col++)
        {
            auto id = chess_board[row][col];
            if (id != 0)
            {
                cout <<setw(5)<< chess_man[id]->name ;//输出一个棋子
            }
            else
            {
                cout<<setw(5) << "_";//表示棋盘上的一个位置
            }
        }
        cout << endl;
        cout << endl;
    }
    return 0;
}

运行结果：

当门炮，马来跳

有了棋子对象之后，我们实现走棋就很好实现了。

    // 当门炮 ： 炮二平五  ID 为 32 从(7,7) 移动到 (7,4)
    chess_man[32]->GoAhead(7, 7, 7, 4);
    // 马来跳 ： 炮8进7  ID 为 8 从(7,7) 移动到 (7,4)
    chess_man[8]->GoAhead(0, 7, 2, 6);

此时，我们需要实现炮，马的 GoAhead 函数。

为了简单起见，我们不做合法性检查，让棋子直接在棋盘上从起点走到终点。

既然如此，其实所有棋子都是这样走棋的，我们把所有的棋子走棋都给实现了：

bool GoAhead(int from_row, int from_col, int to_row, int to_col)
{
    cout << "GoAhead " << from_row << "," << from_col << "," << to_row << "," << to_col << endl;
    //先保存原来的 ID, 为着放到终点
    auto id = chess_board[from_row][from_col];
    //离开之后，留下 0
    chess_board[from_row][from_col] = 0;
    //走到了目的地
    chess_board[to_row][to_col] = id;
    return false;
}

完整的代码

#include <iostream>
#include <string>
#include <vector>
#include <iomanip>
using namespace std;
 
//棋盘数组，不同的数字表示不同的棋子，0表示没有棋子
vector<vector<int>> chess_board
{
    /*      0  1  2  3  4  5  6  7  8*/
    /* 0*/{ 1, 2, 3, 4, 5, 6, 7, 8, 9},
    /* 1*/{ 0, 0, 0, 0, 0, 0, 0, 0, 0},
    /* 2*/{ 0,10, 0, 0, 0, 0, 0,11, 0},
    /* 3*/{12, 0,13, 0,14, 0,15, 0,16},
    /* 4*/{ 0, 0, 0, 0, 0, 0, 0, 0, 0},
    /* 5*/{ 0, 0, 0, 0, 0, 0, 0, 0, 0},
    /* 6*/{26, 0,27, 0,28, 0,29, 0,30},
    /* 7*/{ 0,31, 0, 0, 0, 0, 0,32, 0},
    /* 8*/{ 0, 0, 0, 0, 0, 0, 0, 0, 0},
    /* 9*/{17,18,19,20,21,22,23,24,25},
};

//棋子类的基类
struct chess_base
{
    chess_base(const string& name1):name(name1){}
    // 纯虚函数，表示 chess_base 是一个抽象类，专门用来做基类；
    //GoAhead 用来给各个派生类来重新实现 override
    virtual bool GoAhead(int from_row, int from_col, int to_row, int to_col) = 0;
    string name;//棋子要显示的名字
};
//车 車
struct Chariot : public chess_base
{
    Chariot(const string& name1) :chess_base(name1) {}
    // 马实现自己的走棋
    bool GoAhead(int from_row, int from_col, int to_row, int to_col)
    {
        cout << "GoAhead " << from_row << "," << from_col << "," << to_row << "," << to_col << endl;
        //先保存原来的 ID, 为着放到终点
        auto id = chess_board[from_row][from_col];
        //离开之后，留下 0
        chess_board[from_row][from_col] = 0;
        //走到了目的地
        chess_board[to_row][to_col] = id;
        return false;
    }
};
//马 馬
struct Horse : public chess_base
{
    Horse(const string& name1):chess_base(name1){}
    // 马实现自己的走棋
    bool GoAhead(int from_row, int from_col, int to_row, int to_col)
    {
        cout << "GoAhead " << from_row << "," << from_col << "," << to_row << "," << to_col << endl;
        //先保存原来的 ID, 为着放到终点
        auto id = chess_board[from_row][from_col];
        //离开之后，留下 0
        chess_board[from_row][from_col] = 0;
        //走到了目的地
        chess_board[to_row][to_col] = id;
        return false;
    }
};
//炮 砲
struct Cannon : public chess_base
{
    Cannon(const string& name1) :chess_base(name1) {}
    // 马实现自己的走棋
    bool GoAhead(int from_row, int from_col, int to_row, int to_col)
    {
        cout << "GoAhead " << from_row << "," << from_col << "," << to_row << "," << to_col << endl;
        //先保存原来的 ID, 为着放到终点
        auto id = chess_board[from_row][from_col];
        //离开之后，留下 0
        chess_board[from_row][from_col] = 0;
        //走到了目的地
        chess_board[to_row][to_col] = id;
        return false;
    }
};
//将 帅
struct King : public chess_base
{
    King(const string& name1) :chess_base(name1) {}
    // 帅实现自己的走棋
    bool GoAhead(int from_row, int from_col, int to_row, int to_col)
    {
        cout<<"GoAhead " << from_row << "," << from_col << "," << to_row << "," << to_col << endl;
        //先保存原来的 ID, 为着放到终点
        auto id = chess_board[from_row][from_col];
        //离开之后，留下 0
        chess_board[from_row][from_col] = 0;
        //走到了目的地
        chess_board[to_row][to_col] = id;
        return false;
    }
};
//士 仕
struct Official : public chess_base
{
    Official(const string& name1) :chess_base(name1) {}
    // 帅实现自己的走棋
    bool GoAhead(int from_row, int from_col, int to_row, int to_col)
    {
        cout << "GoAhead " << from_row << "," << from_col << "," << to_row << "," << to_col << endl;
        //先保存原来的 ID, 为着放到终点
        auto id = chess_board[from_row][from_col];
        //离开之后，留下 0
        chess_board[from_row][from_col] = 0;
        //走到了目的地
        chess_board[to_row][to_col] = id;
        return false;
    }
};
//相 象
struct Minister : public chess_base
{
    Minister(const string& name1) :chess_base(name1) {}
    // 帅实现自己的走棋
    bool GoAhead(int from_row, int from_col, int to_row, int to_col)
    {
        cout << "GoAhead " << from_row << "," << from_col << "," << to_row << "," << to_col << endl;
        //先保存原来的 ID, 为着放到终点
        auto id = chess_board[from_row][from_col];
        //离开之后，留下 0
        chess_board[from_row][from_col] = 0;
        //走到了目的地
        chess_board[to_row][to_col] = id;
        return false;
    }
};
//兵 卒
struct Soldier : public chess_base
{
    Soldier(const string& name1) :chess_base(name1) {}
    // 帅实现自己的走棋
    bool GoAhead(int from_row, int from_col, int to_row, int to_col)
    {
        cout << "GoAhead " << from_row << "," << from_col << "," << to_row << "," << to_col << endl;
        //先保存原来的 ID, 为着放到终点
        auto id = chess_board[from_row][from_col];
        //离开之后，留下 0
        chess_board[from_row][from_col] = 0;
        //走到了目的地
        chess_board[to_row][to_col] = id;
        return false;
    }
};

vector<chess_base*> chess_man
{
    nullptr,//下标为0不用，编号从1开始
    //上方黑方棋子
    new Chariot("车"),new Horse("马"), new Minister("相"), new Official("士"), new King("将"), new Official("士"), new Minister("相"), new Horse("马"), new Chariot("车"),

    new Cannon("炮"),new Cannon("炮"),

    new Soldier("兵"), new Soldier("兵"), new Soldier("兵"), new Soldier("兵"), new Soldier("兵"),

    //下方红方棋子
    new Chariot("車"), new Horse("馬"), new Minister("象"), new Official("仕"), new King("帥"), new Official("仕"), new Minister("象"), new Horse("馬"), new Chariot("車"),

    new Soldier("卒"), new Soldier("卒"), new Soldier("卒"), new Soldier("卒"), new Soldier("卒"),

    new Cannon("砲"), new Cannon("砲"),
};


int main(void)
{
    // 当门炮 ： 炮二平五  ID 为 32 从(7,7) 移动到 (7,4)
    chess_man[32]->GoAhead(7, 7, 7, 4);
    // 马来跳 ： 炮8进7  ID 为 8 从(7,7) 移动到 (7,4)
    chess_man[8]->GoAhead(0, 7, 2, 6);



    for (int row = 0; row < 10; row++)
    {
        for (int col = 0; col < 9; col++)
        {
            auto id = chess_board[row][col];
            if (id != 0)
            {
                cout <<setw(5)<< chess_man[id]->name ;//输出一个棋子
            }
            else
            {
                cout<<setw(5) << "_";//表示棋盘上的一个位置
            }
        }
        cout << endl;
        cout << endl;
    }
    return 0;
}

运行效果

C++程序员Carea
关注
专栏目录
C/C++中国象棋（基于easyx图形库）精品
qiaoqiaohonghu的博客
08-21 802
制作一个中国象棋（精品）
原创 关于中国象棋的
qq_44894420的博客
04-24 679
原创 关于中国象棋的
中国象棋C++
11-11
中国象棋 C++ 算法 智能 可以随便看一下，谢谢
c++象棋
qi_programmer的博客
10-04 2738
#include <iostream> #include <memory.h> #include <cmath> using namespace std;//存储结构：chess类是基类，派生类是各种棋子，在chessboard类中用chess的指针调用各个棋子 class chessboard; class chess{ private: int id;//等级 public: chess(int i):id(i){} int get(){return id;} vi.
C++中国象棋
WTC20120518的博客
03-11 1341
C++中国象棋
用C++实现中国象棋
Shuang_Zhu的博客
01-22 7031
项目介绍 最近学习到了STL库，了解到一些很实用的容器，同时我也是个象棋爱好者，想着能不能做个象棋的游戏小程序出来，运用一下所学到的知识点，于是动手做了这个项目，花了两天左右的时间基本完成，不过还有一些功能（将军提示、强制应将和困毙检测等）没做出来，需要后续做一些更新优化，先上图展示一下效果，大家看看还有没有什么地方需要改进的 效果展示 原始局面 除车炮类棋子的步数变化有限，可以列出当前棋子所有的变化，然后用算法判断下一步是否合理，不合理的排除（如超出棋盘范围，下一步点位被己方棋...
rhino-models：在Rhino中创建的几个用于V-Ray的基本3D模型
02-14
大多数几何图形都是从逐步多段线开始的，我对它们进行了镜像，拉伸，复制和其他方式的排列。 使用大理石和菲涅耳材料来创建纹理，并直接从铋照片中获取RGB值，以准确地构建颜色渐变。 卵形 从Portal 2中的合作角色...
PortalGun:控制门炮的代码（来自Rick和Morty）
04-29
控制门炮的代码（来自Rick和Morty） ## Libraries下载并安装以下库： 引脚定义 如果您偏离以下定义，则必须更改固件以解决此问题。 LED显示屏 小饰品专业针 SCL A5 SDA A4 地线 地线 Vcc 5伏 Vi2c 5伏 旋转...
rufasgate:RufasGate：使用Portal进行地牢逃生-开源
04-28
在地牢墙壁上射击门炮，以定义虫洞逃生通道。 但是，要激活它，必须将所有ZPM插入其插槽中。 现在，您只能按ZPM。 这意味着，如果将一个人卷入角落或靠在墙上，您将失败。 RufasGate现在可以在Windows以及Linux和...
AdaGate:使用Ada的3D OpenGL地牢游戏：向Narbacular Drop致敬-开源
04-29
在地牢墙上射击门炮，以配置2个逃生门，但是要激活它们，必须将所有ZPM撞到它们的插槽上。 但要注意：您只能按ZPM，因此，如果将ZPM推入角落或靠在墙上会失败。 但是不用担心，作弊是很容易的。 ）提取归档文件并...
中国象棋游戏(c++)版
12-04
本代码是基于C++的中国象棋游戏，多次检验执行是没有问题的，代码是打包过的。可以参考。。。。。。。。。。。。。。。。。
C++象棋游戏C++象棋游戏C++象棋游戏
03-11
C++象棋游戏C++象棋游戏C++象棋游戏C++象棋游戏C++象棋游戏C++象棋游戏C++象棋游戏C++象棋游戏C++象棋游戏
c++写的象棋游戏
12-10
c++写的象棋游戏，与电脑对战，具有悔棋功能。
中国象棋游戏C++
04-01
中国象棋基本实现，规则全完成，附加棋局匹配，从文件读入走起步骤
中国象棋（visual C++）
03-04
这是一个使用visual C++ 6.0编写的中国象棋程序，包括网络对弈和人机对弈两个模块，但网络对弈不完善。
C++小游戏——象棋
最新发布
weixin_56274053的博客
08-27 335
C++小游戏，可直接复制
使用C++开发的中国象棋游戏(附源代码)
09-23
这是一款使用Qt和C++开发的中国象棋游戏Windows应用程序，里面有已经打包好的一个名为“LittleBoxChess”的Windows可移植应用程序以及一个名为“Chess”的文件夹（里面是整个项目的源代码）。
中国象棋c++中国象棋.zip
03-28
中国象棋c++
/*某典礼上，甲、乙、丙三门礼炮要同时开始鸣放，并分别鸣放 n 响，其中甲礼炮每3秒放一次，乙礼炮每4秒放一次，丙礼炮每5秒放一次。假定没有哑炮，且多门礼炮同时鸣放时听众只能听到一次礼炮声，那么当三门礼炮都鸣放完毕时，听众总共可以听到几次礼炮声？请你设计C程序实现计算任务。 输入格式： 在一行中给出一个正整数n，表示每门炮鸣放的次数。 输出格式： 在一行中输出听众总共可以听到的礼炮声数。c语言
04-19
实现如下： #include <stdio.h> int main() { int n; int count = 0; //听众听到的礼炮声数 scanf("%d", &n); //输入每门炮鸣放的次数 for(int i=1; i<=n; i++) { if(i%3==0 || i%4==0 || i%5==0) //判断是否为甲、乙、丙礼炮响放的时间 count++; //如果是，则听众听到了一次礼炮声 } printf("%d\n", count); //输出听众听到的礼炮声数 return 0; }
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

C++程序员Carea

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值