C++编写一个“人机对弈“的下棋程序，四个棋子连成一线即为赢。人走棋的合法输入为0-6。棋盘是垂直放置，棋子落到底部

已于 2023-11-18 14:20:29 修改
阅读量158 收藏
点赞数
文章标签： c++ 开发语言
于 2023-08-24 00:01:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_64296768/article/details/132450074
版权
本文介绍了一个使用C++编写的四子棋程序，实现了人机对弈，玩家先手，计算机后手，通过判断合法走法、游戏结束条件以及计算最佳策略来决定胜负。
摘要由CSDN通过智能技术生成

题目：编写一个"人机对弈"的下棋程序，四个棋子连成一线即为赢。人走棋的合法输入为0-6。棋盘是垂直放置，棋子落到底部。

说明：这个程序可以选择是计算机先走还是人先走，我们的作业不要求这样，固定为人先走，计算机后走即可

程序结构可以参考如下结构，也可以按自己思路。

class game//这是个抽象类，抽象的是所有人走一步，计算机走一步的对弈游戏
    {
    public:
  enum who { HUMAN, NEUTRAL, COMPUTER }; 
 
  game( ) { move_number = 0; }
  virtual ~game( ) { }
  who play( );   //人先走，计算机后走，返回值是游戏的赢者，后面给出了此函数的定义
    protected:
        //以下虚函数可以被覆盖，也可以不被覆盖
  virtual void display_message(const string& message)const;//在屏幕显示信息message
             virtual int get_user_move( )const;       // 输出"Your move,please:"，然后接受用户输入，并将输入返回
  virtual who last_mover( ) const 
   { return (move_number % 2 == 1 ? HUMAN : COMPUTER); }
  virtual int moves_completed( ) const { return move_number; }
  virtual who next_mover( ) const
   { return (move_number % 2 == 0 ? HUMAN : COMPUTER); }
  
        // 以下虚函数必须被覆盖
     virtual void make_move(const int& move)//将棋子真正下到棋盘上，此函数被子类覆盖
       { ++move_number; }
     virtual void restart( ) { move_number = 0; }//开始新的棋局

        //以下为纯虚函数 
        virtual who winning( )const =0;        //返回胜利者 
     virtual void display_status( )  = 0;   //显示游戏棋盘的当前状态
     virtual bool is_game_over( )  = 0;     //如果游戏结束，返回真
    virtual bool is_legal(const int& move)  = 0;   //如果给定走法为合法，就返回真
        virtual void make_computer_move( )=0;    //计算计算机所有的可能的走法，选出一种最好的，并调用make_move(best_move)
      
 private:
  int move_number; //当前已走的步数
  void make_human_move( );   //调用 get_user_move( )，并用is_legal(move)判断是否合法输入，若是则调用make_move(move)
    };

class c4 : public game//这个类是我们具体要实现的“四子棋”
    {
    public:
     c4( ) {restart( );}
    protected:
  
                virtual void make_move(const int& move); // 修改data[][],many_used[]和most_recent_column的值，并调用game::make_move(move)
  virtual void restart( );    //将data[6][7]各元素置为NEUTRAL，将many_used[7]各元素置为0 ，再调用game::restart();
         virtual game::who winning( )const ;
         virtual void display_status( ) ;  //显示棋盘的状态
  virtual bool is_game_over( ) ;
  virtual bool is_legal(const int& move) ; 
  virtual void make_computer_move( );       
    private:       
  who data[6][7];   //6行7列，表示棋盘
  int many_used[7]; //表示各列中已有多少个棋子
  int most_recent_column;  //最近下的棋子在哪列
    };

//人先走，计算机后走，返回值是游戏的赢者
game::who game::play()
{
 restart();
 
 while(!is_game_over())
 {
  display_status(); 
 
  if(last_mover()==COMPUTER)
   make_human_move();
  else
   make_computer_move();
 }
 display_status();
 return winning();
}
        
void main()
{
 c4 instance;
 game::who winner;
 winner=instance.play();
 switch(winner)
 {
  case c4::HUMAN: cout<<"You win!"<<endl;break;
  case c4::COMPUTER: cout<<"I win!"<<endl;break;
  case c4::NEUTRAL: cout<<"A draw"<<endl;break;
 }
}
 

 

 

实现代码：

#include<iostream>
#include<ctime>
using namespace std;
class game
{
    public:
		 int move_number; 
  enum who { HUMAN, NEUTRAL, COMPUTER}; 
  game( ) { move_number = 0; }
  virtual ~game( ) { };
  who play( );   
    protected:
  virtual int get_user_move( )const;     
  virtual who last_mover( ) const 
  { return (move_number % 2 == 1 ? HUMAN : COMPUTER); }
  virtual int moves_completed( ) const { return move_number; }
  virtual who next_mover( ) const
   { return (move_number % 2 == 0 ? HUMAN : COMPUTER); }
  virtual void make_move(const int& move)
       { ++move_number; }
  virtual void restart( ) { move_number = 0; }
        virtual who winning( )const =0;         
     virtual void display_status( )  = 0;   
     virtual bool is_game_over( )  = 0;    
    virtual bool is_legal(const int& move)  = 0;   
        virtual void make_computer_move( )=0;    
 private:
  void make_human_move( );  
    };
int game::get_user_move()const
{  int step;
	cout<<"Your move,please:";
	cin>>step;
	return step;
}
void game::make_human_move()
{   int step;
	step=get_user_move();
	if(is_legal(step))
	make_move(step);
	else
	{cout<<"The move is illegal!"<<endl;
      make_human_move();
	}
}
class c4 : public game
    {
    public:
     c4( ) {restart( );}
    protected:
  virtual void make_move(const int& move); 
  virtual void restart( );   
  virtual game::who winning( )const ;
  virtual void display_status( ) ; 
  virtual bool is_game_over( ) ;
  virtual bool is_legal(const int& move) ; 
  virtual void make_computer_move( );      
  bool if_two();
  bool if_three();
    private:       
  who data[6][7];   
  int many_used[7]; 
  int most_recent_column;  
    };
bool c4::is_game_over()
{int i,j;
	if(move_number==42) return true;
	for(i=0;i<6;++i)
	{
		for(j=0;j<4;++j)
		{
			if(data[i][j]!=NEUTRAL&&data[i][j]==data[i][j+1]&&data[i][j]==data[i][j+2]&&data[i][j]==data[i][j+3])
				return true;
		}
	}
    for(i=0;i<3;++i)
	{
		for(j=0;j<7;++j)
		{
			if(data[i][j]!=NEUTRAL&&data[i][j]==data[i+1][j]&&data[i][j]==data[i+2][j]&&data[i][j]==data[i+3][j])
				return true;
		}
	}
	for(i=0;i<3;++i)
	{
		for(j=0;j<4;++j)
		{
			if(data[i][j]!=NEUTRAL&&data[i][j]==data[i+1][j+1]&&data[i][j]==data[i+2][j+2]&&data[i][j]==data[i+3][j+3])
				return true;
		}
	}
	for(i=0;i<3;++i)
    {
        for(j=6;j>2;--j)
		{
        if(data[i][j]!=NEUTRAL&&data[i][j]==data[i+1][j-1]&&data[i][j]==data[i+2][j-2]&&data[i][j]==data[i+3][j-3])
        return true;
		}
    }
	return false;

}
bool c4::if_two()
{
	int i,j;
	for(i=0;i<6;++i)
	{
		for(j=0;j<6;++j)
		{
			if(data[i][j]!=NEUTRAL&&data[i][j]==data[i][j+1])
				return true;
		}
	}
	for(i=0;i<5;++i)
	{
		for(j=0;j<7;++j)
		{
			if(data[i][j]!=NEUTRAL&&data[i][j]==data[i+1][j])
				return true;
		}
	}
	for(i=0;i<5;++i)
	{
		for(j=0;j<6;++j)
		{
			if(data[i][j]!=NEUTRAL&&data[i][j]==data[i+1][j+1])
				return true;
		}
	}
	for(i=0;i<5;++i)
	{
		for(j=6;j>0;--j)
		{
             if(data[i][j]!=NEUTRAL&&data[i][j]==data[i+1][j-1])
				return true;
		}
	}
	return false;
}
bool c4::if_three()
{
	int i,j;
	for(i=0;i<6;++i)
	{
		for(j=0;j<5;++j)
		{
			if(data[i][j]!=NEUTRAL&&data[i][j]==data[i][j+1]&&data[i][j]==data[i][j+2])
				return true;
		}
	}
	for(i=0;i<4;++i)
	{
		for(j=0;j<7;++j)
		{
			if(data[i][j]!=NEUTRAL&&data[i][j]==data[i+1][j]&&data[i][j]==data[i+2][j])
				return true;
		}
	}
	for(i=0;i<4;++i)
	{
		for(j=0;j<5;++j)
		{
			if(data[i][j]!=NEUTRAL&&data[i][j]==data[i+1][j+1]&&data[i][j]==data[i+2][j+2])
				return true;
		}
	}
	for(i=0;i<4;++i)
	{
		for(j=6;j>0;--j)
		{
             if(data[i][j]!=NEUTRAL&&data[i][j]==data[i+1][j-1]&&data[i][j]==data[i+2][j-2])
				return true;
		}
	}
	return false;
}
bool c4::is_legal(const int& move)
{
	if(many_used[move]<6&&move>=0&&move<7)
		return true;
	else 
		return false;
}

game::who c4::winning()const
{
   if(move_number==6*7)
       return NEUTRAL;
    else
		return game::last_mover();
}
 
void c4::make_computer_move()
{
	if(move_number==1)
	{
		while(rand()>=6)
		{
		   most_recent_column=rand()%6;
		}
	    make_move(most_recent_column);
     	return ;
	}
     int i,mark;
    int move,score[7],max_score=0,best_move=0;
    for(i=0;i<7;i++)
	{
        score[i]=0;
	}
   for(move=0;move<7;move++)
    {
        if(many_used[move]<6)
        {
            data[5-many_used[move]][move]=COMPUTER;
            if(is_game_over()&&is_legal(move))
              {
               make_move(move);
               return ;
              }
             data[5-many_used[move]][move]=NEUTRAL;
        }
    }
  for(move=0;move<7;move++)
  {
      if(many_used[move]<6)
      {
        data[5-many_used[move]][move]=HUMAN;
        if(is_game_over()&&is_legal(move))
           {
             make_move(move);
             return ;
           }
          data[5-many_used[move]][move]=NEUTRAL;
      }
  }
    
      for(move=0;move<7;move++)
      {
          if(is_legal(move))
          {
              data[5-many_used[move]][move]=HUMAN;
              if(if_three())
              {
                  mark=5;
                 if(mark>score[move])
                     score[move]=mark;
              }
              data[5-many_used[move]][move]=NEUTRAL;
          }
          else
              continue;
      }
        for(move=0;move<7;move++)
        {
            if(is_legal(move))
            {
                data[5-many_used[move]][move]=COMPUTER;
                if(if_three())
                {
                    mark=4;
                    if(mark>score[move])
                    score[move]=mark;
                }
                data[5-many_used[move]][move]=NEUTRAL;
            }
            else
                continue;
        }
    for(move=0;move<7;move++)
    {
        if(is_legal(move))
        {
            data[5-many_used[move]][move]=HUMAN;
            if(if_two())
            {
                mark=3;
                if(mark>score[move])
                score[move]=mark;
            }
            data[5-many_used[move]][move]=NEUTRAL;
        }
        else
            continue;
    }
      for(move=0;move<7;move++)
      {
          if(is_legal(move))
          {
              data[5-many_used[move]][move]=COMPUTER;
              if(if_two())
              {
                mark=2;
                  if(mark>score[move])
                      score[move]=mark;
              }
              data[5-many_used[move]][move]=NEUTRAL;
          }
          else
              continue;
      }
    for(i=0;i<7;i++)
        if(max_score<=score[i])
        {
            best_move=i;
            max_score=score[i];
        }
    make_move(best_move);
}
void c4::make_move(const int& move)
{
	most_recent_column=move;
		 if(next_mover()==HUMAN)
		 {
        data[5-many_used[move]][move]=HUMAN;
		 }
         else
		 {
        data[5-many_used[move]][move]=COMPUTER;
		 }
    many_used[move]++;
	game::make_move(move);
}
void c4::display_status()
{
    int i,j;
    for(i=0;i<6;i++)
    {
        cout<<"          ";
        for(j=0;j<7;j++)
        {if(data[i][j]==HUMAN)
            cout<<"  "<<"*";
            else if(data[i][j]==COMPUTER)
             cout<<"  "<<"#";
            else
             cout<<"  "<<".";
        }
         cout<<endl;
    }
    cout<<"            ___________________"<<endl;
    cout<<"            0  1  2  3  4  5  6"<<endl;
    cout<<"                               Human:*   Computer:#"<<endl;
    cout<<"当前各列棋子数分别为：";
    for(i=0;i<7;i++)
        cout<<" "<<many_used[i];
    cout<<endl;
   cout<<"当前已经走的步数："<<move_number<<endl;
}  
void c4::restart()
{
	int i,j;
	for(i=0;i<6;++i)
	{
		for(j=0;j<7;++j)
		{
			data[i][j]=NEUTRAL;
			many_used[j]=0;
		}
	}
	game::restart();
}
game::who game::play()
{
 restart();
 
 while(!is_game_over())
 {
  display_status(); 
 
  if(last_mover()==COMPUTER)
   make_human_move();
  else
   make_computer_move();
 }
 display_status();
 return winning();
}    
void main()
{
 srand((unsigned int)time(NULL));
 c4 instance;
 game::who winner;
 winner=instance.play();
 switch(winner)
 {
  case c4::HUMAN: cout<<"You win!"<<endl;break;
  case c4::COMPUTER: cout<<"Sorry,the computer win."<<endl;break;
  case c4::NEUTRAL: cout<<"A draw"<<endl;break;
 }
}

运行结果：

5b4f431e40b1410c86fca685ec3e4006.png

 

 

我是MUC的废物
关注
专栏目录
C++实现人机对战围棋（使用Leela Zero权重）-界面
juebai123的博客
08-05 3186
1。在《leela-zero-next》包中有一个 从人类游戏训练的（较弱的）网络的权重文件（https://sjeng.org/zero/best_v1.txt.zip）（6残差块，128通道） 2。并在《easyx吧》百度贴吧下了一个双人对战的五子棋+围棋的游戏（去掉其中的五子棋部分）。 把这两个合成一个人机对战围棋。 虽然leela-zero也是C++写的，但是我也看不懂，这里只使用...
vc++6.0 下实现的 立体四子棋 程序 （原型来源于北京科技馆）
时时除草，时时耕耘
06-26 1082
注意事项 1 要在工程设置里，连接选项的对象库模块中添加opengl32.lib glu32.lib glaux.lib 2  要设置创建的工程类型不是控制台程序而是win32程序 按键说明 F1     且换全屏与否（分辨率默认为1240*800） ESC   推出游戏 L      是否显示阴影效果（默认显示） W，S，A，D控制当前位置在X，Y轴的上下左右移动 R，F
Connect Four四子棋c++程序 - 用户交互（1）
Irlyue的博客
06-08 3895
文章目录回顾用户交互 回顾 上一个博客里我们只是简单地显示了一个窗口，这次我们把主要的游戏逻辑给它加进去。这一部分里我们要做的任务有： 控制帧率：即每秒渲染多少帧； 用户交互：处理用户的鼠标点击事件； 完成相关棋子的渲染。 用户交互 先把整段代码放出来 // connect_four_1.h #ifndef CONNECT_FOUR_１_H #define CONNECT_FOUR_１_H ...
VC++6.0下使用C制作的四子棋小游戏
04-10
这款游戏是在VC环境下使用C编译完成的，其中包含了自己制作的GRAPHICS.H头文件
四子棋c语言程序
03-11
这是一个用c语言编写的四子棋小程序，本程序作为一个平台使用，对战双方可以分别编写一个人工智能程序进行对战，特别锻炼编程初学者的编程能力。
C语言程序五子棋人机对弈程序
11-08
本篇将深入探讨如何使用C语言编写一个五子棋的人机对弈程序，主要涉及的知识点包括：数据结构、算法设计、用户交互以及基本的C语言编程技巧。 一、数据结构设计 在C语言中，实现五子棋游戏的关键在于如何有效地...
c++编写六子棋对弈程序
07-13
六子棋是一种棋类游戏，在一个6×6的棋盘上，双方轮流下子，先将6个自己的棋子连成一条线的一方获胜。下面是一个简单的六子棋对弈程序。 首先，我们需要定义一个6×6的棋盘，可以用一个二维数组来表示。其中，空格...
四子棋智能下棋C语言实现
03-15
四子棋是一种简单而有趣的双人对弈游戏，玩家通过在棋盘上交替放置棋子，尝试连成四颗棋子的直线以取得胜利。在这个项目中，我们使用C语言来实现一个四子棋的智能下棋系统，这涉及到计算机算法、游戏规则的编程以及...
C++简单的五子棋程序
04-10
首先，我们要了解游戏的基本规则：五子棋（Gomoku）是两个人之间的对弈游戏，目标是在棋盘上连成五颗同色的棋子，无论是横、竖还是斜线。在C++中，我们通常会用二维数组来模拟棋盘，每个元素代表一个棋位，可以存储...
Connect Four四子棋c++程序 - 显示窗口（0）
Irlyue的博客
06-08 4220
文章目录Prerequisite显示窗口 Prerequisite 最近在学c++，直接看书学习基础语法有点无聊，于是希望结合游戏开发来深入了解这门语言。网上搜罗了一番，决定从四子棋（connect four）着手，大概300来行代码。这个系列目前只实现了“人人对战模式”，“人机博弈”的算法有空再完善它。首先说一下编程环境： 编程语言：c++ 游戏开发库：SDL-2.0 开发环境：windows...
三维四子棋
04-14
原型来自中国科技馆。采用OpenGL编程实现，可以锻炼空间想象力和三维上的逻辑思考能力，同时辅助空间立体几何的教学。
四子棋【人人/人机对战】
07-08
四子棋 数据结构 C++ 人人对战 人机对战
【华为OD机试真题 JS】竖直四子棋
weixin_40767375的博客
07-03 600
标题：竖直四子棋| 竖直四子棋的棋盘是竖立起来的，双方轮流选择棋盘的一列下子，棋子因重力落到棋盘底部或者其他棋子之上，当一列的棋子放满时，无法再在这列上下子。一方的4个棋子横、竖或者斜方向连成一线时获胜。现给定一个棋盘和红蓝对弈双方的下子步骤，判断红方或蓝方是否在某一步获胜。......
JavaFX Connect4(四子棋)
TreepoBear的博客
11-02 1028
Connect 4 四子棋的棋盘共有6行7列，棋盘是垂直摆放，每名玩者有21只圆形棋子，以不同颜色辨别。两名玩者轮流每次把一只棋子放进棋盘任何未全满的一行中，棋子会占据一行中最底未被占据的位置。两名玩者任何一方先以四只棋子在横，竖或斜方向联成一条直线，便可获胜，游戏亦结束。假如棋盘已完全被棋子填满，但仍未有任何一方成功把四只棋子成一直线，则成为和局。 实体 我们对Markdown编辑器进行了一些...
LC-3 简易四子棋游戏设计
m0_74175922的博客
01-27 1095
深圳大学计算机系统Ⅰ实验 汇编语言编写简易四子棋 游戏设计
【华为OD】C卷真题 200分 100%通过： 竖直四子棋 C/C++代码实现【思路+代码】
十年以上编程经验的干货分享
02-12 1170
题目描述：竖直四子棋的棋盘是竖立起来的，双方轮流选择棋盘的一列下子，棋子因重力落到棋盘底部或者其他棋子之上，当一列的棋子放满时，无法再在这列上下子。一方的4个棋子横、竖或者斜方向连成一线时获胜。现给定一个棋盘和红蓝对弈双方的下子步骤，判断红方或蓝方是否在某一步获胜。
C++自创棋类小游戏
喷火龙廖的博客
01-31 779
今天给大家带来我花了1周时间自创的小游戏，博主还是一名小学生，希望大家提提意见。这是我写的最长的C++代码，希望大家喜欢，不要抄袭，代码共1328行，任何编译器都可以。
LC-3简易四子棋（深大计系1实验4） 思路+代码+详细注释
AKGWSB 's blog
05-26 8214
明天做LC-3的四子棋实验，但是我想睡懒觉就今天把他做了，这个实验挺难的，要写好久还容易出bug，我把自己的思路和代码分享一下，让大家少走弯路 目录前置知识标号伪操作TRAP伪指令代码块（函数）调用题目描述实现思路流程判断胜利思路矩阵存放与填写测试结果代码 前置知识 在做实验前要掌握LC-3的一些伪指令和操作 标号 标号 = 内存地址 （可以这么粗略的理解，编译器建立了名字到内存的映射） 伪操作 特性：相当于库函数了，调用这些伪操作，编译器自动帮你做一些工作，标号以.开头，下面给出标号的解释表格
【华为OD】C卷真题 200分 100%通过： 竖直四子棋 C语言代码实现【思路+代码】
最新发布
十年以上编程经验的干货分享
03-21 59
第二行依次间隔指定红蓝双方的落子步骤，第1步为红方的落子，第2步为蓝方的落子，第3步为红方的落子，以此类推。非法落子步骤有两种，一是列的编号超过棋盘范围，二是在一个已经落满子的列上落子。竖直四子棋的棋盘是竖立起来的，双方轮流选择棋盘的一列下子，棋子因重力落到棋盘底部或者其他棋子之上，当一列的棋子放满时，无法再在这列上下子。步骤由空格分隔的一组数字表示，每个数字为落子的列的编号（最左边的列编号为1，往右递增）。在第7步，红方在第4列落下一子后，红方的四个子在第一行连成一线，故红方获胜，输出 7,red。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值