C语言小游戏--三子棋

最新推荐文章于 2024-07-17 10:38:14 发布
最新推荐文章于 2024-07-17 10:38:14 发布
阅读量394 收藏 5
点赞数 7
分类专栏： C语言：从入门到精通 文章标签： 开发语言 c语言 学习 Powered by 金山文档
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Yikefore/article/details/128714512
版权

今天给大家分享一个关于C语言的一个小游戏，首先得有一定的代码基础，分享的这个小游戏，最主要不是用来玩，主要是用来锻炼我们组织大型代码的能力，话不多说，正文开始：

📌三子棋：

在写代码之前我们先来了解一下这个小游戏，说三子棋很多老铁可能有点陌生，但是说井字棋就豁然开朗，我们首先来看代码实现的总体效果是什么样的：

字体有点小，可以慢慢看，理清逻辑关系。

📌文件的创建：

我们为了逻辑关系清晰，所以创建多个文件：

创建一个头文件：game.h 用来包含我们的头文件和函数的声明以及其他的定义

创建一个源文件：game.c 用来实现关于游戏的函数

再创建一个源文件：test.c 用来测试游戏的基本逻辑

    • 打印菜单和基本选择逻辑：

当我们创建好这些文件之后，我们在test.c里面实现游戏的基本逻辑：

首先，我们先要打印一个菜单，然后供玩家选择，如果玩家玩完一次还想玩还可以继续，不想玩直接退出就行，所以我们需要一个do while的循环，我们把头文件全部包含到game.h里面，然后在包含game.h就行了

头文件：game.h:

//game.h的头文件
#pragma once

//包含头文件：
#include<stdio.h>

源文件:test.c:

#include "game.h"   //包含game.h的头文件

void menu()         //打印菜单的函数，不需要返回，所以返回类型是void
{
    printf("********************\n");
    printf("****  1. play  *****\n");
    printf("****  0. exit  *****\n");
    printf("********************\n");
}

int main()
{
    int input = 0;
    do         //do while循环来实现多次操作
    {
        menu();
        printf("请选择:>");
        scanf("%d", &input);
    } while (input);    //这里的进入循环的条件是input为真（非0），如果为假（0），则不会进入循环
    return 0;
}

打印完菜单之后，就要完善这个菜单带来的效果了，选择play，则进入三子棋游戏，如果选择exit，则退出游戏吧！所以我们就需要用到switch case语句来进行选择

完善过后的do while循环：

int main()
{
    int input = 0;
    do
    {
        menu();
        printf("请选择:>");
        scanf("%d", &input);
        switch (input)        //将输入进来的值进行判断
        {
        case 1:              //如果为1，则玩游戏
            printf("三子棋游戏：\n");
            break;
        case 0:             //如果为0，则退出游戏
            printf("退出游戏\n");
            break;
        default:            //既不是1也不是0，选择错误，重新选择吧
            printf("选择错误，请重新选择\n");
            break;
        }
    } while (input);
    return 0;
}

我们选1要进行三子棋游戏，所以我们要分装一个game函数，来实现三子棋游戏

    • game函数：

在创建一个game函数之后，首先我们得创建一个二维数组，再初始化棋盘，将其初始化为空格

所以我们要在switch case语句中的case 1：中加入game函数

源文件：test.c :

switch (input)        
        {
        case 1:         
            printf("三子棋游戏：\n");
            game();    //游戏逻辑的函数
            break;
void game()
{
    char board[3][3] = { 0 };   //创建一个二维数组3*3

    //初始化棋盘：
    InitBoard(board, 3, 3);  //将数组，行，列都传给这个函数实现初始化棋盘
}

在这里有一个创建二维数组的好方法：

我们可以在头文件里面用#define来定义ROW为行，定义COL为列，然后赋值，因为如果我们要改变这个棋盘的大小，我们需要把我们整个程序里面的所有关于行和列的值全部修改，所以太麻烦，因此我们只需要在头文件中定义行和列，在后期需要改变的时候直接在头文件里面进行修改，非常方便，所以我们需要改动一下我们写出的代码：

头文件：game.h:

//行和列的定义

#define ROW 3
#define COL 3

源文件：test.c：

void game()
{
    char board[ROW][COL] = { 0 };

    //初始化棋盘：
    InitBoard(board, ROW, COL);  //将数组，行，列都传给这个函数实现初始化棋盘
}

修改好之后就来进入我们的初始化棋盘这个函数：

2.1初始化棋盘：

我们初始化棋盘来设定一个函数：InitBoard

源文件：test.c：

void game()
{
    char board[ROW][COL] = { 0 };

    //初始化棋盘：
    InitBoard(board, ROW, COL);  //将数组，行，列都传给这个函数实现初始化棋盘
}

然后先要在头文件里面声明

头文件：game.h：

//函数的声明：
//初始化棋盘
void InitBoard(char board[ROW][COL], int row, int col);  //不需要返回什么所以返回类型是void

在声明函数之后，我们在game.c里面来实现这个初始化棋盘这个函数：

初始化棋盘就是说将这个二维数组里面的元素先初始化为空格，有两种方法，我们一一来介绍：

第一种：遍历这个数组中的每一个元素，将其修改为空格

源文件：game.c：

//遍历每一个元素进行修改
void InitBoard(char board[ROW][COL], int row, int col)
{
    int i = 0;
    int j = 0;
    for (i = 0; i < row; i++)
    {
        for (j = 0; j < col; j++)
        {
            board[i][j] = ' ';
        }
    }
}

第二种：使用memset函数来初始化

void InitBoard(char board[ROW][COL], int row, int col)
{
    memset(&board[row][col], ' ', row * col * sizeof(board[0][0]));
}
//使用memset时需要包含头文件#include<string.h>

两种方法都可以用。

在初始化棋盘过后，我们把初始化的棋盘打印出来，再分装一个打印棋盘的函数

2.2打印棋盘：

设定一个打印棋盘的函数：PrintfBoard

源文件：test.c：

void game()
{
    char board[ROW][COL] = { 0 };

    //初始化棋盘：
    InitBoard(board, ROW, COL);  //将数组，行，列都传给这个函数实现初始化棋盘
   //打印棋盘
    PrintfBoard(board, ROW, COL);
}

设定好了之后先在头文件里面声明

头文件game.h：

//函数的声明：
//初始化棋盘
void InitBoard(char board[ROW][COL], int row, int col);

//打印棋盘：
void PrintfBoard(char board[ROW][COL], int row, int col);

在game.c里面来实现这个打印棋盘的函数：

首先我们得知道我们要打印什么：

虽然我们初始化了棋盘，但是我们得给棋盘来分割一下，看起来比较明显，也利于玩家下棋

那这种分割线怎么来打印呢？

我们一步一步来进行分析：首先得设置总的打印行数，我们将一个“ %c | %c | %c |”（%c的前后都有空格）看作一组，将一个“---|---|---|”也看作一组，所以我们需要打印三行嘛，先写出这个代码：

void PrintfBoard(char board[ROW][COL], int row, int col)
{
    int i = 0;
    for (i = 0; i < row; i++)
    {
        printf(" %c | %c | %c |", board[i][0], board[i][1], board[i][2]);
        printf("\n");
        printf("---|---|---|", board[i][0], board[i][1], board[i][2]);
        printf("\n");
    }
}

如果这样写，就多打印了一行“---|---|---|”和“ %c | %c | %c |”,所以我们打印的时候就设置if语句来少打印一行

void PrintfBoard(char board[ROW][COL], int row, int col)
{
    int i = 0;
    for (i = 0; i < row; i++)
    {
            printf(" %c | %c | %c |", board[i][0], board[i][1], board[i][2]);
            printf("\n");
        
        if (i < row - 1)
        {
            printf("---|---|---|", board[i][0], board[i][1], board[i][2]);
            printf("\n");
        }
        
    }
}

可以看到，在我们修改完之后，后面还是多了一列的“|”，再加上这种写法本身是存在缺陷，这里的列是固定的，无法灵活的修改，所以我们采用新的方法

我们可以将“ %c |”这样的一个看成一组，但是在打印最后一组时，只打印“ %c ”，不打印“|”，同时，我们也要将“---|”这样的看成一组，只需要打印两行即可。

//打印棋盘：
void PrintfBoard(char board[ROW][COL], int row, int col)
{
    int i = 0;
    for (i = 0; i < row; i++)      //设置一个需要打印几行
    {
        int j = 0;
        for (j = 0; j < col; j++)   //设置打印“ %c |”的行数
        {
            printf(" %c ", board[i][j]);   
            if (j < col - 1)        //因为最后一列不需要打印“|”
            {
                printf("|");
            }
                
                
        }
        printf("\n");       //打印完之后换行
        if (i < row - 1)    //在打印“---|”是比打印“ %c |”少一行
        {
            for (j = 0; j < col; j++)   //设置打印多少行的“---|”
            {
                printf("---");
                if (j < col - 1)      //最后一列也不需要打印“|”
                {
                    printf("|");
                }
            }
        }
        printf("\n");
    }
}

可以看到，棋盘很好的打印了出来，接下来就需要轮到我们来进行下棋的环节了

2.3玩家下棋：

假如我们设置玩家先下棋把，然后再电脑下棋，那么首先来设置玩家下棋的函数

设定一个函数：PlayerMove

源文件：test.c：

void game()
{
    char board[ROW][COL] = { 0 };

    //初始化棋盘：
    InitBoard(board, ROW, COL);  //将数组，行，列都传给这个函数实现初始化棋盘

    //打印棋盘：
    PrintfBoard(board, ROW, COL);

    //玩家下棋：
    PlayerMove(board,ROW,COL);
    PrintfBoard(board, ROW, COL);   //下完棋之后打印出棋盘
}

设定好先在头文件里面声明

头文件：game.h：

//函数的声明：
//初始化棋盘
void InitBoard(char board[ROW][COL], int row, int col);

//打印棋盘：
void PrintfBoard(char board[ROW][COL], int row, int col);

//玩家下棋：
void PlayerBoard(char board[ROW][COL], int row, int col);

声明好了之后，我们在game.c中实现这个函数：

源文件：game.c：

//玩家下棋：
void PlayerBoard(char board[ROW][COL], int row, int col)
{
    printf("玩家下棋\n");
    int x = 0;
    int y = 0;
    while (1)        //设置死循环，如果输入非法就一直输入，如果输入正确就跳出循环
    {
        printf("请输入你所要下棋的坐标:>");
        scanf("%d %d", &x, &y);
        if (x >= 1 && x <= row && y >= 1 && y <= col) //用来判断坐标的合法性
        {
            if (board[x-1][y-1] != ' ')  //因为玩家通常不会认为数组的下标是从0开始的
            {                             //他们通常认为下标是1，所以玩家输入的坐标-1才能得到棋盘                                           //中的坐标
                printf("该位置已经落子，请重新输入坐标:>");
            }
            else
            {
                board[x-1][y-1] = '*';
                break;    //输入成功，则跳出循环
            }
        }
        else   //如果输入非法，重新输入
        {
            printf("输入非法，请重新输入:>");
        }
    }
}

玩家下完棋打印出棋盘，再是电脑下完棋打印棋盘

2.4电脑下棋：

电脑下棋的话，我们就让电脑随机下棋，下完棋再打印出棋盘，所以需要再设置一个电脑下棋的函数

设定一个函数：ComputerMove

源文件：test.c：

void game()
{
    char board[ROW][COL] = { 0 };

    //初始化棋盘：
    InitBoard(board, ROW, COL);  //将数组，行，列都传给这个函数实现初始化棋盘

    //打印棋盘：
    PrintfBoard(board, ROW, COL);

    //玩家下棋：
    PlayerBoard(board, ROW, COL);
    PrintfBoard(board, ROW, COL);

    //电脑下棋：
    ComputerMove(board, ROW, COL);
    PrintfBoard(board, ROW, COL);    //下完棋打印出棋盘
}

头文件里面要声明这个函数：

头文件game.h：

//函数的声明：
//初始化棋盘
void InitBoard(char board[ROW][COL], int row, int col);

//打印棋盘：
void PrintfBoard(char board[ROW][COL], int row, int col);

//玩家下棋：
void PlayerBoard(char board[ROW][COL], int row, int col);

//电脑下棋：
void ComputerMove(char board[ROW][COL], int row, int col);

电脑下棋是随机下棋，所以我们需要用到rand函数来生成随机数，并且在主函数中需要设置

源文件：game.c：

//电脑下棋
void ComputerMove(char board[ROW][COL], int row, int col)
{
    int x = 0;
    int y = 0;
    printf("电脑下棋:>\n");
    x = rand() % row;     //生成随机数，要在头文件中包含#include<stdlib.h>
    y = rand() % col;     //rang（）%row的意思就是随机生成0~2之间的数
    while (1)
    {
        if (board[x][y] == ' ')  //因为电脑下棋就是按照二维数组的小标来下的所以不用改
        {
            board[x][y] = '#';
            break;
        }
    }
}

在使用rand函数时要在main函数中加上

srand((unsigned int)time(NULL));

源文件：test.c：

int main()
{
    int input = 0;
    srand((unsigned int)time(NULL));  //在使用time函数时也需要包含头文件#include<time.h>
    do
    {
        menu();
        printf("请选择:>");
        scanf("%d", &input);
        switch (input)        //将输入进来的值进行判断
        {
        case 1:         //如果为1，则玩游戏
            printf("三子棋游戏：\n");
            game();
            break;
        case 0:    //如果为0，则退出游戏
            printf("退出游戏\n");
            break;
        default: //既不是1也不是0，选择错误，重新选择吧
            printf("选择错误，请重新选择\n");
            break;
        }
    } while (input);
    return 0;
}

头文件：game.h：

//包含头文件：
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<time.h>

2.5判断输赢：

在玩家下完棋之后需要进行判断输赢，如果赢了，则跳出，没赢就继续，在电脑下完棋之后也需要进行判断，那假如棋盘下满了，没有人胜出，则为平局。一共四种情况，所以我们要分装一个判断输赢的函数

这个函数一共要处理四种情况，玩家赢、电脑赢、平局、继续游戏，所以我们假设：如果玩家赢，返回‘*’，如果电脑赢，返回‘#’，如果平局，返回‘P’，谁都没赢游戏继续，返回‘Q’,所以我们要用一个值来接收返回的字符

设定一个函数：IsWin

源文件：test.c：

void game()
{
    int ret = 0;
    char board[ROW][COL] = { 0 };

    //初始化棋盘：
    InitBoard(board, ROW, COL);  //将数组，行，列都传给这个函数实现初始化棋盘

    //打印棋盘：
    PrintfBoard(board, ROW, COL);

    //玩家下棋：
    PlayerBoard(board, ROW, COL);
    PrintfBoard(board, ROW, COL);
    //判断输赢：
    ret = IsWIN(board, ROW, COL);

    //电脑下棋：
    ComputerMove(board, ROW, COL);
    PrintfBoard(board, ROW, COL);
    //判断输赢：
    ret = IsWIN(board, ROW, COL);

    
}

头文件中也要声明函数

头文件：game.h：

//函数的声明：
//初始化棋盘
void InitBoard(char board[ROW][COL], int row, int col);

//打印棋盘：
void PrintfBoard(char board[ROW][COL], int row, int col);

//玩家下棋：
void PlayerBoard(char board[ROW][COL], int row, int col);

//电脑下棋：
void ComputerMove(char board[ROW][COL], int row, int col);

//判断输赢：
char IsWin(char board[ROW][COL], int row, int col);

在源文件game.c中来实现我们的函数

判断玩家赢还是电脑赢就是行连成三子，列连成三子，对角线连成三子，若为平局，就证明整个棋盘满了，也就是没有空格了，但要注意，排除空格，因为三个空格连成一起也不行

源文件：game.c：

char IsWin(char board[ROW][COL], int row, int col)
{
    int i = 0;
    for (i = 0; i < row; i++)
    {
        if (board[i][0] == board[i][1] && board[i][1] == board[i][2] && board[i][0] != ' ')
            return board[i][0];       //判断三行是否相同
    }
    for (i = 0; i < row; i++)
    {
        if (board[0][i] == board[1][i] && board[1][i] == board[2][i] && board[1][i] != ' ')
            return board[1][i];     //判断三列是否相同
    }
    //判断对角线
    if (board[0][0] == board[1][1] && board[1][1] == board[2][2] && board[0][0] != ' ')
    {
        return board[0][0];
    }
    if (board[0][2] == board[1][1] && board[1][1] == board[2][0] && board[1][1] != ' ')
    {
        return board[1][1];
    }
    //判断平局再分装一个函数IsFull
    if (IsFull(board, row, col))  //可以看到这里与上面的函数不同的是，
    {
        return 'P';      //平局返回‘P ’ 
    }
    return 'Q';       //若上面的条件一个都没有发生，则返回‘Q’
}

分装一个判断是否平局的函数：同样的也要在头文件中声明

2.5.1判断是否平局：

头文件：game.h：

//函数的声明：
//初始化棋盘
void InitBoard(char board[ROW][COL], int row, int col);

//打印棋盘：
void PrintfBoard(char board[ROW][COL], int row, int col);

//玩家下棋：
void PlayerBoard(char board[ROW][COL], int row, int col);

//电脑下棋：
void ComputerMove(char board[ROW][COL], int row, int col);

//判断输赢：
char IsWin(char board[ROW][COL], int row, int col);

//判断是否平局
int IsFull(char board[ROW][COL], int row, int col);
//由于这里要接收返回值所以设置返回类型为int

源文件：game.c：

char IsWin(char board[ROW][COL], int row, int col)
{
    int i = 0;
    for (i = 0; i < row; i++)
    {
        if (board[i][0] == board[i][1] && board[i][1] == board[i][2] && board[i][0] != ' ')
            return board[i][0];
    }
    for (i = 0; i < row; i++)
    {
        if (board[0][i] == board[1][i] && board[1][i] == board[2][i] && board[1][i] != ' ')
            return board[1][i];
    }
    if (board[0][0] == board[1][1] && board[1][1] == board[2][2] && board[0][0] != ' ')
    {
        return board[0][0];
    }
    if (board[0][2] == board[1][1] && board[1][1] == board[2][0] && board[1][1] != ' ')
    {
        return board[1][1];
    }
    if (IsFull(board, row, col))   //如果返回为真，则进入
    {
        return 'P';
    }
    return 'Q';
}

IsFull函数的实现：

源文件：game.c：

int IsFull(char board[ROW][COL], int row, int col)
{
    int i = 0;
    int j = 0;
    for (i = 0; i < row; i++)   //遍历一下整个数组看有没有存在空格
    {
        for (j = 0; j < col; j++)
        {
            if (board[i][j] == ' ')
            {
                return 0;
            }
        }
    }
    return 1;
}

当我们的一整套流程写完之后，就该在game函数里面来接收这些返回值了：

源文件：test.c：

void game()
{
    int ret = 0;
    char board[ROW][COL] = { 0 };

    //初始化棋盘：
    InitBoard(board, ROW, COL);  //将数组，行，列都传给这个函数实现初始化棋盘

    //打印棋盘：
    PrintfBoard(board, ROW, COL);

    while (1)   //由于这些下棋的过程是一个循环，只有当有人胜出或者平局才会跳出循环
    {
        //玩家下棋：
        PlayerBoard(board, ROW, COL);
        PrintfBoard(board, ROW, COL);
        //判断输赢：
        ret = IsWIN(board, ROW, COL);     //设置一个变量来接收返回值
        if (ret != 'Q')       //如果ret不是‘Q’，则证明就有人胜出或者平局，则会跳出循环
        {
            break;
        }

        //电脑下棋：
        ComputerMove(board, ROW, COL);
        PrintfBoard(board, ROW, COL);
        //判断输赢：
        ret = IsWIN(board, ROW, COL);
        if (ret != 'Q')
        {
            break;
        }
    }
    //当跳出循环后，我们就应该判断是谁赢，还是平局
    if (ret == '*')
    {
        printf("恭喜你，你赢了！\n");
    }
    else if (ret == '#')
    {
        printf("很遗憾，你输了!\n");
    }
    else if (ret == 'p')
    {
        printf("平局\n");
    }
}

一整套的程序都写完了，在写程序的时候，我们要注意几点：

  1. 使用函数时要在头文件里面声明

  1. 使用的每一个库函数都要注意包含头文件

  1. 写完一个函数先让它运行一下，测试当前写的这个函数对不对

  1. 在设定函数时要注意设定的函数的返回类型

    • 整个程序代码：

头文件：game.h：

#pragma once

//包含头文件：
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<time.h>

//行和列的定义

#define ROW 3
#define COL 3


//函数的声明：
//初始化棋盘
void InitBoard(char board[ROW][COL], int row, int col);

//打印棋盘：
void PrintfBoard(char board[ROW][COL], int row, int col);

//玩家下棋：
void PlayerBoard(char board[ROW][COL], int row, int col);

//电脑下棋：
void ComputerMove(char board[ROW][COL], int row, int col);

//判断输赢：
char IsWin(char board[ROW][COL], int row, int col);

//判断是否平局
int IsFull(char board[ROW][COL], int row, int col);

源文件：game.c：

#define _CRT_SECURE_NO_WARNINGS 1

#include "game.h"

//初始化棋盘
void InitBoard(char board[ROW][COL], int row, int col)
{
    int i = 0;
    int j = 0;
    for (i = 0; i < row; i++)
    {
        for (j = 0; j < col; j++)
        {
            board[i][j] = ' ';
        }
    }
    //memset(&board[row][col], ' ', row * col * sizeof(board[0][0]));
}

//打印棋盘：
void PrintfBoard(char board[ROW][COL], int row, int col)
{
    int i = 0;
    for (i = 0; i < row; i++)
    {
        int j = 0;
        for (j = 0; j < col; j++)
        {
            printf(" %c ", board[i][j]);
            if (j < col - 1)
            {
                printf("|");
            }
                
                
        }
        printf("\n");
        if (i < row - 1)
        {
            for (j = 0; j < col; j++)
            {
                printf("---");
                if (j < col - 1)
                {
                    printf("|");
                }
            }
        }
        printf("\n");
    }
}

//玩家下棋：
void PlayerBoard(char board[ROW][COL], int row, int col)
{
    printf("玩家下棋\n");
    int x = 0;
    int y = 0;
    while (1)
    {
        printf("请输入你所要下棋的坐标:>");
        scanf("%d %d", &x, &y);
        if (x >= 1 && x <= row && y >= 1 && y <= col)
        {
            if (board[x-1][y-1] != ' ')
            {
                printf("该位置已经落子，请重新输入坐标:>\n");
            }
            else
            {
                board[x-1][y-1] = '*';
                break;
            }
        }
        else
        {
            printf("输入非法，请重新输入:>\n");
        }
    }
}


//电脑下棋
void ComputerMove(char board[ROW][COL], int row, int col)
{
    int x = 0;
    int y = 0;
    printf("电脑下棋:>\n");
    x = rand() % row;
    y = rand() % col;
    while (1)
    {
        if (board[x][y] == ' ')
        {
            board[x][y] = '#';
            break;
        }
    }
}
//判断平局：
int IsFull(char board[ROW][COL], int row, int col)
{
    int i = 0;
    int j = 0;
    for (i = 0; i < row; i++)
    {
        for (j = 0; j < col; j++)
        {
            if (board[i][j] == ' ')
            {
                return 0;
            }
        }
    }
    return 1;
}

//判断输赢：
char IsWin(char board[ROW][COL], int row, int col)
{
    int i = 0;
    for (i = 0; i < row; i++)
    {
        if (board[i][0] == board[i][1] && board[i][1] == board[i][2] && board[i][0] != ' ')
            return board[i][0];
    }
    for (i = 0; i < row; i++)
    {
        if (board[0][i] == board[1][i] && board[1][i] == board[2][i] && board[1][i] != ' ')
            return board[1][i];
    }
    if (board[0][0] == board[1][1] && board[1][1] == board[2][2] && board[0][0] != ' ')
    {
        return board[0][0];
    }
    if (board[0][2] == board[1][1] && board[1][1] == board[2][0] && board[1][1] != ' ')
    {
        return board[1][1];
    }
    if (IsFull(board, row, col))
    {
        return 'P';
    }
    return 'Q';
}

源文件：test.c：

#define _CRT_SECURE_NO_WARNINGS 1

#include "game.h"
void game()
{
    int ret = 0;
    char board[ROW][COL] = { 0 };

    //初始化棋盘：
    InitBoard(board, ROW, COL);  //将数组，行，列都传给这个函数实现初始化棋盘

    //打印棋盘：
    PrintfBoard(board, ROW, COL);

    while (1)
    {
        //玩家下棋：
        PlayerBoard(board, ROW, COL);
        PrintfBoard(board, ROW, COL);
        //判断输赢：
        ret = IsWin(board, ROW, COL);
        if (ret != 'Q')
        {
            break;
        }

        //电脑下棋：
        ComputerMove(board, ROW, COL);
        PrintfBoard(board, ROW, COL);
        //判断输赢：
        ret = IsWin(board, ROW, COL);
        if (ret != 'Q')
        {
            break;
        }
    }
    if (ret == '*')
    {
        printf("恭喜你，你赢了！\n");
    }
    else if (ret == '#')
    {
        printf("很遗憾，你输了!\n");
    }
    else if (ret == 'p')
    {
        printf("平局\n");
    }
}

void menu()
{
    printf("********************\n");
    printf("****  1. play  *****\n");
    printf("****  0. exit  *****\n");
    printf("********************\n");
}

int main()
{
    int input = 0;
    srand((unsigned int)time(NULL));
    do
    {
        menu();
        printf("请选择:>");
        scanf("%d", &input);
        switch (input)        //将输入进来的值进行判断
        {
        case 1:         //如果为1，则玩游戏
            printf("三子棋游戏：\n");
            game();
            break;
        case 0:    //如果为0，则退出游戏
            printf("退出游戏\n");
            break;
        default: //既不是1也不是0，选择错误，重新选择吧
            printf("选择错误，请重新选择\n");
            break;
        }
    } while (input);
    return 0;
}

三子棋小游戏就写完了，如果本篇有什么疑问或者不足，大家可以私信或者在评论区指出，感谢大家阅读！

stackY、
关注
  • 7
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 6
    评论
专栏目录
用C语言实现三子棋小游戏
08-08
三子棋是一种民间传统游戏，又叫九宫棋、圈圈叉叉、一条龙、井字棋等。将正方形对角线连起来，相对两边依次摆上三个双方棋子，只要将自己的三个棋子走成一条线，对方就算输了。但是，有很多时候会出现和棋的情况。 1...
C语言实现三子棋小游戏
08-28
C语言实现三子棋小游戏 本资源主要介绍了使用C语言实现三子棋小游戏的方法，包括游戏的基本结构、游戏棋盘的初始化、游戏棋子的下棋方法、计算机自动下棋的方法、游戏胜利的判断方法等方面的内容。 1. 游戏基本...
c语言小游戏--三子棋
Martinous的博客
01-24 2584
一.问题描述 二.步骤 1.菜单界面 2.初始化棋盘 3.打印棋盘 4.玩家走 5.电脑走 6.判断输赢 三.结果演示 1.玩家赢 2.电脑赢 3.平局 四.完整代码 目录 一.问题描述 二.步骤 1.菜单界面 2.初始化棋盘 3.打印棋盘 4.玩家走 5.电脑走 6.判断输赢 三.结果演示 1.玩家赢 2.电脑赢 3.平局 四.完整代码 一.问题描述 二.步骤 1.菜单界面 2.初始化棋盘 3.打印棋盘 4.玩家走 5.电脑走 ...
C语言小游戏---三子棋
忆梦初心的博客
01-14 712
我们知道，三子棋的棋盘是一个3X3的棋盘，棋盘上的每个点代表一个棋子。因此我们可以用一个3X3的的二维数组来存储棋盘上每个点的棋子。而棋盘的行数和列数，我们使用宏定义的方式进行实现。除此之外，当游戏出现胜负时，我们需要创建一个变量来表示不同的游戏结果。//棋盘上的棋子//ret=='c' 表示游戏继续//ret=='*' 表示玩家胜利//ret=='#' 表示电脑胜利//ret=='p' 表示游戏平局//打印菜单//初始化数组//打印棋盘//玩家下棋//电脑下棋//判断胜负。
C语言小游戏-三子棋详解
m0_53117341的博客
08-23 2099
三子棋-C语言实现一、游戏介绍二、问题描述三、基本流程 一、游戏介绍 三子棋，是由一个3*3组成的棋盘构成的，只要将自己的三个棋子走成一条线，对方就算输了，即下的棋子只要达到一横行、一纵列或对角线全下满，游戏就成功了。但是如果对方达到一横行、一纵列或对角线全下满而玩家没有堵住的话，那么游戏就失败了。 二、问题描述 本篇文章实现的是用C语言实现三子棋的具体步骤，需要用到的相关知识有if语句、switch语句、while语句、do-while语句、函数、数组、C语言基础语法以及随机数的生成等。 三、基本流程
C语言----三子棋小游戏
weixin_52937076的博客
05-04 1365
三子棋相信大家都玩过，九宫格，三个子连起来就算赢。 用C语言写小游戏其实不难，我们要注重思想及清晰的流程。
c语言小游戏--三子棋(详解)--通俗易懂的代码
void_sk的博客
11-12 797
初学c语言,三子棋游戏小项目,非常详细,可以直接上手.c语言的练习
C语言小游戏 - - “三子棋”
小乔不掉发的博客
09-20 981
代码采用模块化思想： game.h 模块: 存放 头文件和函数声明 #define _CRT_SECURE_NO_WARNINGS 1 #include <stdio.h> #include <stdlib.h> #include <time.h> //全局变量，方便修改后期棋盘的大小 #define COL 3//列 #define ROW 3//行 #define COUNT 3 void menu(void); void game(void); void I
C语言入门游戏---三子棋
weixin_67120523的博客
09-06 958
c语言实现三子棋小游戏
C语言小游戏--三子棋（井字棋）附完整源码
touchinaiyou的博客
01-20 535
C语言小游戏--三子棋（井字棋）附完整源码
C语言小游戏----三子棋
拾至名瑰的博客
05-01 268
迟来的小游戏之三子棋，哈哈哈哈哈好久之前本来就要写这篇博客，因为有事情就一直拖着，接下来就给大家详细的讲解小游戏三子棋. 文章目录前言一、运行菜单二、用户选择三、游戏的实现1.棋盘的初始化2.打印棋盘四、用户下棋五、电脑下棋六、判断棋盘是否为空七、判断输赢八、拓展总结 前言 首先是需要的头文件如下 定义行和列 这个#pragma once是防止包含有多个头文件，因为代码比较多了，就需要分模块去做，每个模块有着自己的工作 这个小游戏就分为了三个模块 Game.h;//游戏代码的声明（函数声明，符号定.
c语言实现三子棋小游戏-.zip
04-15
C#通常用于开发Windows桌面应用程序、Web应用程序、移动应用程序以及游戏开发等领域。C#是.NET框架的一部分，这意味着它可以与其他.NET语言（如Visual Basic .NET、F#等）以及.NET框架中的各种库和工具进行交互使用...
基于C语言实现的三子棋小游戏
02-14
在基于C语言实现的三子棋小游戏中，我们可以通过以下方式实现： 1. 创建一个3x3的二维数组表示棋盘，每个元素可以是空、X或者O。 2. 设计一个函数来打印当前的棋盘状态，显示每个位置上的符号。 3. 实现一个函数...
java内部类的本质
qq_43593646的博客
07-12 774
可以定义一个类Pair，包括最大值和最小值，但Pair这个名字太普遍，而且它主要是类内部使用的，就可以定义为一个静态内部类。内部类访问了外部类的一个私有静态变量shared，而我们知道私有变量是不能被类外部访问的，Java的解决方法是：自动为Outer生成一个非私有访问方法access$0，它返回这个私有静态变量shared。外部类的一些方法的返回值可能是某个接口，为了返回这个接口，外部类方法可能使用内部类实现这个接口，这个内部类可以被设为private，对外完全隐藏。
[C/C++入门][ifelse]19、制作一个简单计算器
最新发布
qq_14840819的专栏
07-17 206
毕竟谁计算运算是先输数字，再输入符号，并且还要输一下空格一下，那么有没有好的方法，像作业本上写计算一样丝滑呢？这是一种非常方便的方式来解析字符串中的数据，尤其是当字符串格式较为复杂时。被初始化为一个字符串时，它意味着你可以开始解析这个字符串，就像处理普通的输入流一样。可以看作是连接字符串和流的一个桥梁，它允许我们像处理输入/输出流一样来读写字符串。字符串的内容，但同时它也具备流的所有特性，包括能够从中读取和向其中写入数据。然后输入的时候，用不同类型的变量来接收，就可以从开头获取字符串中对应的数据了。
C语言（7.4）
fhgfyrsg的博客
07-15 135
在cmd里面输入的东西必须和scanf括号里面引号里面的格式一模一样， 引号里是%d %d，在cmd里面输入的东西就必须是数字 数字，比如10 29 引号里是%d，%d，在cmd里面输入的东西就必须是数字，数字。printf("我的姓名为：%s\n年龄：%d\n身高：%f\n", name,age,high);今天做了一些关于键盘录入的基本训练。
华清c基础day10 24-7-12
m0_62859255的博客
07-12 142
【代码】华清c基础day10 24-7-12。
C判断一个点在三角形上
一个大佬的博客
07-14 1101
三角形三等分点定理是指在任意三角形ABC中，可以找到三个点D、E和F，使得线段AD、BE和CF均等分三角形ABC。这意味着三个等分点分别位于三个边界上，并且每个等分点都将三角形划分为等面积部分。如何判断在矩形，任意多边形上？（提示：计算多边形面积是等于点切割多边形面积和）鼠标操作时，经常要判断是否命中显示控件，特开发此算法快速判断。
用c语言写一个三子棋的小游戏
04-05
对不起，我是一名语言模型，无法提供代码。但我可以为您提供一个三子棋的基本游戏规则： 1. 游戏双方各执一种颜色的棋子，在棋盘上交替落子。 2. 棋盘为3x3的方格，每个方格可落子一次。 3. 先在横向、纵向或对角线上连成三个同色棋子的一方获胜，若棋盘填满且没有一方获胜，则为平局。 您可以根据这些规则进行编写。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 6
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

stackY、

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

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

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

打赏作者

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

抵扣说明：

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

余额充值