三子棋+迷宫

news2025/6/15 19:09:53

又水了一篇，嘿嘿不废话了，正文开始
在这里插入图片描述

文章目录

  • 1.三子棋（Tic-Tac-Toe）
    • 游戏流程解析
    • 游戏设计
    • 游戏代码实现
      • 1. 包含头文件和定义全局变量
      • 2. 初始化游戏板
      • 3. 打印游戏板
      • 4. 玩家行动
      • 5. 检查胜利条件
      • 6. 主函数
      • 下面是完整的C语言代码
  • 2.控制台迷宫
    • 游戏逻辑和功能解释
    • 迷宫游戏设计
    • 核心代码实现
      • 1. 包含头文件和定义全局变量
      • 2. 初始化迷宫
      • 3. 玩家移动
      • 4. 游戏循环和输入处理
      • 5. 迷宫打印
      • 动态障碍物
      • 6. 初始化和移动障碍物
      • 时间限制
      • 7. 添加时间限制
      • 游戏主函数
      • 完整代码

1.三子棋（Tic-Tac-Toe）

三子棋是一个双人游戏，玩家轮流在3x3的网格中放置自己的符号（通常是X和O）。第一个在横线、竖线或对角线上形成一条线的玩家获胜。

游戏流程解析

  1. 初始化棋盘：调用initBoard()函数，使用双重循环将棋盘的每个格子初始化为空格' '。
  2. 打印棋盘：printBoard()函数展示棋盘当前状态，以图形方式显示，包括格子和分隔线。
  3. 玩家移动：playerMove()函数询问玩家输入行和列数字，将相应位置标记为玩家的符号（X或O）。输入验证确保所选位置未被占用且在棋盘范围内。
  4. 检查胜利条件：checkWin()函数检查是否有连成一线的情况，包括横线、竖线和两个对角线。
  5. 游戏结束判断：在main()函数的循环中，每次玩家操作后都会检查是否有玩家胜出或所有格子都已填满（即平局）。

游戏设计

三子棋的游戏板是一个3x3的矩阵，我们将使用一个二维数组来表示。玩家将通过选择行和列来放置他们的标记。

游戏代码实现

1. 包含头文件和定义全局变量

#include <stdio.h>
#include <stdlib.h>

#define SIZE 3

char board[SIZE][SIZE];  // 游戏板

2. 初始化游戏板

void initBoard() 
{
    for (int i = 0; i < SIZE; i++) 
    {
        for (int j = 0; j < SIZE; j++) 
        {
            board[i][j] = ' ';
        }
    }
}

3. 打印游戏板

void printBoard() {
    for (int i = 0; i < SIZE; i++)
     {
        for (int j = 0; j < SIZE; j++) 
        {
            printf(" %c ", board[i][j]);
            if (j < SIZE - 1) 
            {
                printf("|");
            }
        }
        printf("\n");
        if (i < SIZE - 1)
         {
            printf("---+---+---\n");
        }
    }
}

4. 玩家行动

void playerMove(char symbol)
 {
    int x, y;
    do
     {
        printf("Enter row and column for %c: ", symbol);
        scanf("%d%d", &x, &y);
        x--; y--;  // 将用户输入调整为基于0的索引
    } while (x < 0 || x >= SIZE || y < 0 || y >= SIZE || board[x][y] != ' ');

    board[x][y] = symbol;
}

5. 检查胜利条件

int checkWin() 
{
    for (int i = 0; i < SIZE; i++) 
    {
        // 检查行
        if (board[i][0] == board[i][1] && board[i][1] == board[i][2] && board[i][0] != ' ') 
        {
            return 1;
        }
        // 检查列
        if (board[0][i] == board[1][i] && board[1][i] == board[2][i] && board[0][i] != ' ') 
        {
            return 1;
        }
    }
    // 检查对角线
    if (board[0][0] == board[1][1] && board[1][1] == board[2][2] && board[0][0] != ' ') 
    {
        return 1;
    }
    if (board[0][2] == board[1][1] && board[1][1] == board[2][0] && board[0][2] != ' ')
     {
        return 1;
    }
    return 0;
}

6. 主函数

int main() 
{
    initBoard();
    int turn = 0;  // 0代表X, 1代表O
    int won = 0;

    while (!won) 
    {
        printBoard();
        playerMove(turn % 2 == 0 ? 'X' : 'O');
        won = checkWin();
        turn++;
        if (turn == SIZE * SIZE && !won) 
        {
            printf("The game is a draw.\n");
            break;
        }
    }

    printBoard();
     if (won) {
        printf("Congratulations! Player %c wins!\n", turn % 2 == 1 ? 'X' : 'O');
    } else {
        printf("The game is a draw.\n");
    }

    return 0;
}

下面是完整的C语言代码

#include <stdio.h>

#define SIZE 3

char board[SIZE][SIZE];

void initBoard() 
{
    for (int i = 0; i < SIZE; i++) 
    {
        for (int j = 0; j < SIZE; j++) 
        {
            board[i][j] = ' ';
        }
    }
}

void printBoard() 
{
    for (int i = 0; i < SIZE; i++)
     {
        for (int j = 0; j < SIZE; j++) 
        {
            printf(" %c ", board[i][j]);
            if (j < SIZE - 1)
             {
                printf("|");
            }
        }
        printf("\n");
        if (i < SIZE - 1) 
        {
            printf("---+---+---\n");
        }
    }
}

void playerMove(char symbol) 
{
    int x, y;
    do
     {
        printf("Enter row and column for %c (e.g., 1 1 for top-left): ", symbol);
        scanf("%d%d", &x, &y);
        x--; y--;  // 将用户输入调整为基于0的索引
    } while (x < 0 || x >= SIZE || y < 0 || y >= SIZE || board[x][y] != ' ');

    board[x][y] = symbol;
}

int checkWin() 
{
    // Check rows and columns
    for (int i = 0; i < SIZE; i++) 
    {
        if ((board[i][0] == board[i][1] && board[i][1] == board[i][2] && board[i][0] != ' ') ||
            (board[0][i] == board[1][i] && board[1][i] == board[2][i] && board[0][i] != ' ')) 
            {
            return 1;  // There's a win
        }
    }

    // Check diagonals
    if ((board[0][0] == board[1][1] && board[1][1] == board[2][2] && board[0][0] != ' ') ||
        (board[0][2] == board[1][1] && board[1][1] == board[2][0] && board[0][2] != ' ')) {
        return 1;  // There's a win
    }

    return 0;  // No win yet
}

int main() 
{
    initBoard();
    int turn = 0;
    int won = 0;

    while (!won && turn < SIZE * SIZE) 
    {
        printBoard();
        playerMove(turn % 2 == 0 ? 'X' : 'O');
        won = checkWin();
        turn++;
    }

    printBoard(); // Print the final state of the board
    if (won) 
    {
        printf("Congratulations! Player %c wins!\n", turn % 2 == 1 ? 'X' : 'O');
    }
     else
      {
        printf("The game is a draw.\n");
    }

    return 0;
}

2.控制台迷宫

此游戏不仅包括生成迷宫和玩家导航，还引入了动态障碍和时间限制来增加挑战性噢，嘿嘿，一起来看看吧。

游戏逻辑和功能解释

这段代码组织了迷宫游戏的所有核心功能，并且通过以下各部分实现了游戏的完整流程：

  1. 初始化迷宫 (initMaze函数)：创建一个MAZE_SIZE x MAZE_SIZE的迷宫，其中边界由#字符组成，中间为空格，标记了玩家的初始位置P和出口位置E。

  2. 初始化和移动障碍物 (initObstacles和moveObstacles函数)：障碍物在迷宫中随机生成，并且每次玩家输入后随机移动。障碍物移动时会检查目标位置是否为空，如果不是，它们会反弹到相反方向。

  3. 玩家移动 (movePlayer函数)：玩家通过输入w, s, a, d来控制上下左右移动。该函数检查目标位置是否可行（即是否为空格或出口）并相应更新玩家位置。

  4. 时间限制 (setTimer和alarmHandler函数)：使用UNIX信号和alarm函数设置一个实时计时器，当时间耗尽时，触发alarmHandler函数，该函数会输出消息并终止程序。

  5. 游戏循环和清屏：游戏在一个持续的循环中运行，每次循环都会清屏并重新打印迷宫和剩余时间，直到玩家到达出口或时间耗尽。

迷宫游戏设计

  1. 迷宫生成：使用递归分割法（Recursive Division Method）生成迷宫。
  2. 玩家导航：允许用户通过键盘输入上（W）、下（S）、左（A）、右（D）来控制角色移动。
  3. 动态障碍：障碍物会在迷宫内移动，玩家需要避免接触障碍物。
  4. 时间限制：玩家需要在限定时间内到达终点。

核心代码实现

1. 包含头文件和定义全局变量

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <stdbool.h>
#include <unistd.h>

#define MAZE_SIZE 20
#define OBSTACLE_COUNT 5

char maze[MAZE_SIZE][MAZE_SIZE];
int playerPosition[2] = {1, 1}; // [y, x]
int exitPosition[2] = {MAZE_SIZE - 2, MAZE_SIZE - 2}; // [y, x]

2. 初始化迷宫

void initMaze()
 {
    for (int y = 0; y < MAZE_SIZE; y++) 
    {
        for (int x = 0; x < MAZE_SIZE; x++) 
        {
            if (y == 0 || y == MAZE_SIZE - 1 || x == 0 || x == MAZE_SIZE - 1) {
                maze[y][x] = '#'; // 边界
            } 
            else 
            {
                maze[y][x] = ' '; // 可走路径
            }
        }
    }
    maze[playerPosition[0]][playerPosition[1]] = 'P'; // 玩家位置
    maze[exitPosition[0]][exitPosition[1]] = 'E'; // 出口位置
}

3. 玩家移动

void movePlayer(char direction)
{
    int dx = 0, dy = 0;
    switch (direction) 
    {
        case 'W': case 'w': dy = -1; break;
        case 'S': case 's': dy = 1; break;
        case 'A': case 'a': dx = -1; break;
        case 'D': case 'd': dx = 1; break;
    }
    int newY = playerPosition[0] + dy;
    int newX = playerPosition[1] + dx;
    if (maze[newY][newX] == ' ' || maze[newY][newX] == 'E')
     {
        maze[playerPosition[0]][playerPosition[1]] = ' ';
        playerPosition[0] = newY;
        playerPosition[1] = newX;
        maze[playerPosition[0]][playerPosition[1]] = 'P';
    }
}

4. 游戏循环和输入处理

void gameLoop() 
{
    char input;
    bool gameRunning = true;
    while (gameRunning) 
    {
        system("clear"); // 清屏
        printMaze();
        scanf(" %c", &input); // 获取玩家输入
        movePlayer(input);
        // 检查是否到达出口
        if (playerPosition[0] == exitPosition[0] && playerPosition[1] == exitPosition[1]) 
        {
            printf("Congratulations, you've reached the exit!\n");
            gameRunning = false;
        }
    }
}

5. 迷宫打印

void printMaze()
 {
    for(int y = 0; y < MAZE_SIZE; y++) 
    {
        for (int x = 0; x < MAZE_SIZE; x++) 
        {
            printf("%c ", maze[y][x]);
        }
        printf("\n");
    }
}

动态障碍物

为了增加游戏的挑战性，我们将在迷宫中添加动态障碍物，这些障碍物会在每个时间步随机移动，如果玩家与障碍物相遇，则游戏结束。

6. 初始化和移动障碍物

typedef struct
 {
    int y, x;
    int dy, dx;
}
 Obstacle;

Obstacle obstacles[OBSTACLE_COUNT];

void initObstacles()
 {
    srand(time(NULL)); // 为随机数生成初始化种子
    for (int i = 0; i < OBSTACLE_COUNT; i++)
     {
        obstacles[i].x = 2 + rand() % (MAZE_SIZE - 4);
        obstacles[i].y = 2 + rand() % (MAZE_SIZE - 4);
        obstacles[i].dx = (rand() % 3) - 1; // 随机方向 -1, 0, 1
        obstacles[i].dy = (rand() % 3) - 1;
        maze[obstacles[i].y][obstacles[i].x] = 'O'; // 在迷宫中标记障碍物位置
    }
}

void moveObstacles() 
{
    for (int i = 0; i < OBSTACLE_COUNT; i++)
    {
        int newY = obstacles[i].y + obstacles[i].dy;
        int newX = obstacles[i].x + obstacles[i].dx;
        if (newY > 0 && newY < MAZE_SIZE - 1 && newX > 0 && newX < MAZE_SIZE - 1 && maze[newY][newX] == ' ') 
        {
            maze[obstacles[i].y][obstacles[i].x] = ' '; // 清除旧位置
            obstacles[i].y = newY;
            obstacles[i].x = newX;
            maze[obstacles[i].y][obstacles[i].x] = 'O'; // 标记新位置
        } 
        else
         { // 如果障碍物撞墙，则改变方向
            obstacles[i].dx = -obstacles[i].dx;
            obstacles[i].dy = -obstacles[i].dy;
        }
    }
}

时间限制

为了增加游戏的紧迫感，我们可以设置一个时间限制。如果玩家在规定时间内未能到达出口，则游戏失败。

7. 添加时间限制

#include <signal.h>
#include <unistd.h>

int timeLimit = 30; // 时间限制30秒

void alarmHandler(int sig)
 {
    printf("Time's up! You didn't make it to the exit.\n");
    exit(0); // 直接退出程序
}

void setTimer(
) {
    signal(SIGALRM, alarmHandler);
    alarm(timeLimit); // 设置定时器
}

游戏主函数

将所有的功能整合到主函数中，开始游戏循环。

int main() {
    initMaze();
    initObstacles();
    setTimer();
    gameLoop();
    return 0;
}

完整代码

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <stdbool.h>
#include <unistd.h>
#include <signal.h>

#define MAZE_SIZE 20
#define OBSTACLE_COUNT 5

char maze[MAZE_SIZE][MAZE_SIZE];
int playerPosition[2] = {1, 1}; // [y, x]
int exitPosition[2] = {MAZE_SIZE - 2, MAZE_SIZE - 2}; // [y, x]
int timeLimit = 30; // 时间限制30秒

typedef struct
 {
    int y, x;
    int dy, dx;
} Obstacle;

Obstacle obstacles[OBSTACLE_COUNT];

void printMaze() 
{
    for (int y = 0; y < MAZE_SIZE; y++) 
    {
        for (int x = 0; x < MAZE_SIZE; x++)
         {
            printf("%c ", maze[y][x]);
        }
        printf("\n");
    }
    printf("\n");
}

void initMaze() 
{
    for (int y = 0; y < MAZE_SIZE; y++) 
    {
        for (int x = 0; x < MAZE_SIZE; x++) 
        {
            maze[y][x] = (y == 0 || y == MAZE_SIZE - 1 || x == 0 || x == MAZE_SIZE - 1) ? '#' : ' ';
        }
    }
    maze[playerPosition[0]][playerPosition[1]] = 'P';
    maze[exitPosition[0]][exitPosition[1]] = 'E';
}

void initObstacles() 
{
    srand(time(NULL));
    for (int i = 0; i < OBSTACLE_COUNT; i++) {
        obstacles[i].x = 2 + rand() % (MAZE_SIZE - 4);
        obstacles[i].y = 2 + rand() % (MAZE_SIZE - 4);
        obstacles[i].dx = (rand() % 3) - 1;
        obstacles[i].dy = (rand() % 3) - 1;
        maze[obstacles[i].y][obstacles[i].x] = 'O';
    }
}

void moveObstacles() 
{
    for (int i = 0; i < OBSTACLE_COUNT; i++)
     {
        int newY = obstacles[i].y + obstacles[i].dy;
        int newX = obstacles[i].x + obstacles[i].dx;
        if (newY > 0 && newY < MAZE_SIZE - 1 && newX > 0 && newX < MAZE_SIZE - 1 && maze[newY][newX] == ' ')
         {
            maze[obstacles[i].y][obstacles[i].x] = ' ';
            obstacles[i].y = newY;
            obstacles[i].x = newX;
            maze[obstacles[i].y][obstacles[i].x] = 'O';
        } 
        else 
        {
            obstacles[i].dx = -obstacles[i].dx;
            obstacles[i].dy = -obstacles[i].dy;
        }
    }
}

void movePlayer(char direction)
 {
    int dx = 0, dy = 0;
    switch (direction) 
    {
        case 'w': dy = -1; break;
        case 's': dy = 1; break;
        case 'a': dx = -1; break;
        case 'd': dx = 1; break;
    }
    int newY = playerPosition[0] + dy;
    int newX = playerPosition[1] + dx;
    if (maze[newY][newX] == ' ' || maze[newY][newX] == 'E') 
    {
        maze[playerPosition[0]][playerPosition[1]] = ' ';
        playerPosition[0] = newY;
        playerPosition[1] = newX;
        maze[newY][newX] = 'P';
    }
}

void alarmHandler(int sig)
 {
    printf("Time's up! You didn't make it to the exit.\n");
    exit(0);
}

void setTimer() 
{
    signal(SIGALRM, alarmHandler);
    alarm(timeLimit);
}

int main() 
{
    initMaze();
    initObstacles();
    setTimer();
    char input;
    bool gameRunning = true;
    while (gameRunning) 
    {
        system("clear"); // 在Windows下使用cls
        printM
        aze();
        printf("Use 'w', 's', 'a', 'd' to move. You have %d seconds left.\n", timeLimit);
        scanf(" %c", &input);
        movePlayer(input);
        moveObstacles();

        // Check if player reached the exit
        if (playerPosition[0] == exitPosition[0] && playerPosition[1] == exitPosition[1]) 
        {
            printf("Congratulations, you've reached the exit!\n");
            gameRunning = false;
        }
    }

    return 0;
}

在这里插入图片描述
如果有对你有帮助！那真的！泰酷辣

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1589065.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

机器学习——概述总结

机器学习——概述总结

总图&#xff1a; 分部1&#xff1a; 分部2&#xff1a; 分部3&#xff1a;
阅读更多...
计算机基础知识-第7章-程序的本质（2）——算法与数据结构概论

计算机基础知识-第7章-程序的本质（2）——算法与数据结构概论

一、算法数据结构程序 提出这一公式并以此作为其一本专著的书名的瑞士计算机科学家尼克劳斯沃思&#xff08;Niklaus Wirth&#xff09;由于发明了多种影响深远的程序设计语言&#xff0c;并提出结构化程序设计这一革命性概念而获得了1984年的图灵奖。他是至今惟一获此殊荣的瑞…
阅读更多...
k8s的ca以及相关证书签发流程

k8s的ca以及相关证书签发流程

k8s的ca以及相关证书签发流程 1. kube-apiserver相关证书说明2. 生成CA凭证1.1. 生成CA私钥1.2. 生成CA证书 2. 生成kube-apiserver凭证2.1. 生成kube-apiserver私钥2.2. 生成kube-apiserver证书请求2.3. 生成kube-apiserver证书 3. 疑问和思考4. 参考文档 对于网站类的应用&am…
阅读更多...
C++高级特性：柯里化过程与std::bind（六）

C++高级特性：柯里化过程与std::bind（六）

1、柯里化过程 1.1、operator()的引入 现在需要完成这样一个需求&#xff1a;有一个函数每次调用返回的结果不一样。例如&#xff1a;两次调用的返回值都不一样那么就可以达到这种目的 1.1.1、简单点的写法 可以给一个全局的变量&#xff08;静态变量&#xff09;&#xff…
阅读更多...
交换机与路由器缓冲区：寻找完美大小

交换机与路由器缓冲区：寻找完美大小

*本文系SDNLAB编译自瞻博网络技术专家兼高级工程总监Sharada Yeluri领英 在路由器和交换机中&#xff0c;缓冲区至关重要&#xff0c;可以防止网络拥塞期间的数据丢失。缓冲区到底要多大&#xff1f;这个问题在学术界和工业界一直备受争议。本文探讨了高端路由器中数据包缓冲的…
阅读更多...
书生·浦语大模型全链路开源体系-第3课

书生·浦语大模型全链路开源体系-第3课

书生浦语大模型全链路开源体系-第3课 书生浦语大模型全链路开源体系-第3课相关资源RAG 概述在 InternLM Studio 上部署茴香豆技术助手环境配置配置基础环境下载基础文件下载安装茴香豆 使用茴香豆搭建 RAG 助手修改配置文件 创建知识库运行茴香豆知识助手 在茴香豆 Web 版中创建…
阅读更多...
荒野奔驰，在泥泞中体验惊心动魄的冒险

荒野奔驰，在泥泞中体验惊心动魄的冒险

从亚利桑那州的金色沙漠到喀尔巴阡山脉的崇山峻岭&#xff0c;在这片无垠的开放世界中&#xff0c;蕴藏着无尽的宝藏与古老的废墟&#xff0c;等待着勇敢者的发现。《远征&#xff1a;泥泞奔驰游戏》作为Saber Interactive打造的又一越野模拟力作&#xff0c;继《雪地奔驰》之后…
阅读更多...
记录一次Ubuntu 22.04桌面版安装向日葵的过程

记录一次Ubuntu 22.04桌面版安装向日葵的过程

大概花了近一天的时间安装了WIN11和Ubuntu 22.04双系统&#xff0c;中间Ubuntu安装时出现了好几次失败&#xff0c;后来检查可能是下载的iso文件有问题&#xff0c;重新下载一次&#xff0c;刻录到U盘。安装才算成功。 最后的Ubuntu系统信息如下 接着安装向日葵的时候出错了&a…
阅读更多...
模组硬件通用｜ESD静电释放注意事项

模组硬件通用｜ESD静电释放注意事项

当我们在进行接插件操作或者电路板调试时&#xff0c;有时会出现接口损坏或者电路板上的某个IC芯片失效的情况&#xff0c;原因可能仅仅是手触摸到了IC芯片&#xff0c;ESD(Electro-Static discharge 静电释放)导致了损坏。模组作为一个集成电路板&#xff0c;内部含有不同型号…
阅读更多...
003Node.js创建第一个web服务

003Node.js创建第一个web服务

如果用PHP来编写后端代码&#xff0c;需要用Apache或者Nginx的服务器,来处理客户的请求响应。对于Node.js时&#xff0c;不仅实现了应用&#xff0c;同时还实现了整个HTTP服务器. 安装 Node Snippets插件&#xff08;编程自带提示&#xff09; console.log(你好nodejs); //表…
阅读更多...
Golang 并发安全Map容器实践

Golang 并发安全Map容器实践

Golang原生Map容器并非支持并发安全&#xff0c;在实际使用的时候很容易导致条件竞争并造成未知问题&#xff0c;本文介绍了在Golang中如何安全的并发访问Map容器。原文: Concurrent-Safe Map Container in Go Georg Bommeli Unsplash 当多个程序同时尝试写入同一个map时&#…
阅读更多...
【MATLAB源码-第186期】matlab基于MLE算法的8天线阵列DOA估计仿真，对比粗估计、精确估计输出RMSE对比图。

【MATLAB源码-第186期】matlab基于MLE算法的8天线阵列DOA估计仿真，对比粗估计、精确估计输出RMSE对比图。

操作环境&#xff1a; MATLAB 2022a 1、算法描述 第一部分&#xff1a;基本概念与系统设置 方向到达估计&#xff08;Direction of Arrival, DOA&#xff09;是信号处理中一项重要的技术&#xff0c;主要用于确定信号的到达方向。这种技术在雷达、无线通信和声纳等领域中有…
阅读更多...
PandasAI的应用与实战解析（一）：环境安装、运行demo

PandasAI的应用与实战解析（一）：环境安装、运行demo

文章目录 1.源码包下载、明确依赖版本2.安装python依赖3.运行demo 本博客源码仓库地址&#xff1a;gitlab&#xff0c;本篇博客对应01分支python版本为3.10.x 什么是PandasAI&#xff1f;一句话总结的话&#xff0c;PandasAI就是一个结合了Pandas和AI的开源工具&#xff0c;更…
阅读更多...
代码随想录阅读笔记-回溯【组合总和II】

代码随想录阅读笔记-回溯【组合总和II】

题目 给定一个数组 candidates 和一个目标数 target &#xff0c;找出 candidates 中所有可以使数字和为 target 的组合。 candidates 中的每个数字在每个组合中只能使用一次。 说明&#xff1a; 所有数字&#xff08;包括目标数&#xff09;都是正整数。解集不能包含重复的组…
阅读更多...
Pytest精通指南（06）Fixture scope作用域详解

Pytest精通指南（06）Fixture scope作用域详解

文章目录 前言Scope 作用域写在测试用例函数文件写在conftest.py文件作用域总结验证默认作用域验证执行顺序遵循验证类中的fixture作用域验证重名fixture作用域 前言 从前文中&#xff0c;我们已经知道固件&#xff08;fixture&#xff09;的概念、原理、作用域&#xff0c;并且…
阅读更多...
TMS320F280049 EPWM模块--PC子模块（5）

TMS320F280049 EPWM模块--PC子模块（5）

下图是PC子模块和其他子模块的联系图。可以看出&#xff0c;PC接收DB的输出&#xff0c;然后处理后给到TZ。 下图是PC子模块的内部框图。可以看到&#xff1a; 1&#xff09;PC子模块功能可以被bypass&#xff1b; 2&#xff09;one shot和divider的时钟是epwm时钟的8分频&am…
阅读更多...
秋招数据库学习2（20240408-20240412共10道）

秋招数据库学习2（20240408-20240412共10道）

由于感觉数据库难度可能暂时面试用不到&#xff0c;就先不刷啦 20240408 1.从不订购的客户 SELECT Name AS Customers FROM Customers C LEFT JOIN Orders O ON C.Id O.CustomerId WHERE CustomerId is nullselect customers.name as Customers from Customers wher…
阅读更多...
购物车实现

购物车实现

目录 1.购物车常见的实现方式 2.购物车数据结构介绍 3.实例分析 1.controller层 2.service层 1.购物车常见的实现方式 方式一&#xff1a;存储到数据库 性能存在瓶颈方式二&#xff1a;前端本地存储 localstorage在浏览器中存储 key/value 对&#xff0c;没有过期时间。s…
阅读更多...
什么是电子巡查系统？

什么是电子巡查系统？

电子巡检系统&#xff0c;通常又被叫做设备巡检系统&#xff0c;一种利用现代化技术进行设备管理和维护的系统。 通过结合软件应用程序、移动设备和云端服务&#xff0c;设备巡检系统能够实现对设备的全面监测、定位和记录。它使得设备管理人员能够轻松地安排、执行和跟踪设备…
阅读更多...
通讯录项目（用c语言实现）

通讯录项目（用c语言实现）

一.什么是通讯录 通讯录是一种用于存储联系人信息的工具或应用程序。它是一种电子化的地址簿&#xff0c;用于记录和管理个人、机构或组织的联系方式&#xff0c;如姓名、电话号码、电子邮件地址和邮寄地址等。通讯录的目的是方便用户在需要时查找和联系他人。 通讯录通常以列…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023