本文还有配套的精品资源，点击获取 menu-r.4af5f7ec.gif

简介：《猫抓老鼠——C++实现详解》是一篇面向编程学习者的实践教程，通过使用C++语言模拟真实生活场景中的追捕游戏，帮助读者掌握C++基础语法、面向对象编程思想及游戏逻辑设计方法。文章详细讲解了类的设计与封装、继承与多态的应用、游戏主循环机制、碰撞检测逻辑、用户输入处理以及异常和文件操作等核心技术。本项目不仅强化编程基础，还提升逻辑思维与实际开发能力，是C++初学者进行综合项目实践的理想选择。

1. C++基础语法与游戏开发环境搭建

变量、数据类型与输入输出基础

C++程序从 main() 函数开始执行，使用 #include <iostream> 引入标准输入输出流。通过 int x = 10; 定义整型变量， double 、 char 、 bool 等类型支持不同类型的数据存储。利用 std::cin >> x; 实现用户输入， std::cout << "Hello"; 输出信息，结合 \n 或 std::endl 换行，构建基本交互逻辑。

控制结构与函数封装

条件判断使用 if-else 语句控制流程分支，例如根据用户输入决定角色移动方向；循环采用 for 或 while 实现持续运行的游戏帧更新。将重复逻辑封装为函数，如 void PrintMenu() ，提高代码可读性与复用性，函数声明需包含返回类型、名称及参数列表。

开发环境配置与项目初始化

推荐使用Visual Studio Code或Code::Blocks，配合MinGW编译器进行跨平台开发。创建项目目录 cat_mouse_game/src/ 存放 .cpp 文件，使用 g++ main.cpp -o game 编译并生成可执行程序。通过 #include 组织代码模块，确保语法规范与结构清晰，为后续面向对象设计奠定基础。

2. 面向对象编程思想在游戏设计中的应用

面向对象编程（Object-Oriented Programming, OOP）是现代软件工程的核心范式之一，尤其在复杂系统如游戏开发中展现出强大的表达力与可维护性。传统过程式编程以“函数+数据”分离的方式组织逻辑，而OOP则将数据和操作这些数据的方法封装在一起，形成具有独立行为能力的“对象”。这种思维方式更贴近现实世界的建模方式——每一个游戏角色都可以被看作一个独立的对象，拥有自身的状态（属性）和行为（方法），并通过消息传递与其他对象交互。

在“猫抓老鼠”小游戏的设计中，我们不再仅仅关注如何移动字符或判断坐标是否重合，而是从更高层次抽象出“猫”和“老鼠”这两个实体的本质特征：它们都有位置、都能移动、都具备生存状态，但其移动策略、感知能力和目标完全不同。正是这种共性与差异性的并存，使得面向对象的三大核心特性—— 封装、继承、多态 ——成为构建可扩展、易维护游戏架构的关键支柱。通过合理运用这三大机制，开发者可以实现高内聚、低耦合的类结构，从而为后续添加新角色、优化AI算法、支持多人模式等高级功能打下坚实基础。

更为重要的是，OOP不仅是一种语法工具，更是一种设计哲学。它促使开发者在编码前进行充分的领域建模，思考“谁在做什么？”、“它们之间如何关联？”、“未来可能如何变化？”。例如，在初始版本中，猫可能是由玩家控制的，但在后期升级中，我们希望引入AI自动追击；老鼠当前只是随机逃跑，未来或许会具备路径规划能力。如果代码结构僵化、职责混乱，则每一次功能迭代都将付出高昂的重构代价。而借助OOP的思想指导，我们可以预先设计出灵活的基类接口、清晰的权限边界和可替换的行为模块，使整个系统具备良好的演化潜力。

此外，随着C++语言对面向对象特性的深度支持（如虚函数、多重继承、访问控制、构造/析构语义等），我们在实际编码过程中不仅能实现基本的类定义，还能精细地控制对象生命周期、内存布局以及运行时行为绑定。这些底层机制的掌握，直接决定了游戏性能的稳定性与资源管理的安全性。特别是在涉及大量动态创建的游戏角色时，错误的对象销毁顺序或缺失的虚析构函数可能导致严重的内存泄漏甚至程序崩溃。

因此，本章将围绕“猫抓老鼠”这一具体案例，深入剖析面向对象三大特性的技术内涵及其在游戏开发中的实践价值。我们将从理论解析出发，结合UML类图、代码示例与运行时行为分析，逐步建立起一套完整的角色建模范式，并探讨构造函数、析构函数、 this 指针及访问控制符在真实项目中的最佳使用方式。最终目标是让读者不仅“会写类”，更能“设计类”，具备从需求到模型再到代码的系统化设计能力。

2.1 面向对象三大特性解析

面向对象编程之所以能够有效应对复杂系统的建模挑战，关键在于其三大核心特性： 封装、继承、多态 。这三者共同构成了OOP的基石，分别解决了数据安全、代码复用和行为扩展三大问题。在“猫抓老鼠”这类实时交互性强、角色行为多样化的游戏中，正确理解和运用这三项特性，直接影响到系统的可读性、可维护性和可扩展性。

2.1.1 封装：隐藏内部状态与行为，提供公共接口

封装的本质是“信息隐藏”。它要求将对象的内部实现细节（如成员变量、私有方法）对外部世界屏蔽，仅暴露必要的公共接口供其他对象调用。这样做的好处在于：一是防止外部代码随意修改对象状态导致不一致；二是降低模块间的依赖程度，便于后期修改实现而不影响使用者。

以 Cat 类为例，猫的位置（x, y坐标）、速度、方向等属性属于其内部状态，若允许外部直接访问（如 cat.x = 1000; ），极易造成非法值写入或逻辑错乱。通过封装机制，我们可以将这些属性设为 private ，并提供受控的 SetPosition() 和 GetPosition() 方法来间接操作：

class Cat {
private:
    int x, y;           // 私有属性，外部无法直接访问
    int speed;
    char direction;

public:
    void SetPosition(int newX, int newY) {
        if (newX >= 0 && newX <= 100 && newY >= 0 && newY <= 100) {
            x = newX;
            y = newY;
        } else {
            // 可抛出异常或记录日志
        }
    }

    std::pair<int, int> GetPosition() const {
        return std::make_pair(x, y);
    }
};

上述代码中， SetPosition() 方法加入了边界检查，确保坐标合法，体现了封装带来的 数据完整性保护 。同时，用户无需知道 Cat 内部是如何存储坐标的，只需调用接口即可完成操作，实现了 调用者与实现者的解耦 。

特性 实现方式 游戏开发意义
数据隐藏 使用 private 修饰成员变量 防止非法修改角色状态
接口暴露 提供 public 方法 统一访问入口，增强可控性
行为约束 在方法中加入校验逻辑 提升程序健壮性 
classDiagram
    class Cat {
        -int x
        -int y
        -int speed
        +void SetPosition(int, int)
        +pair~int,int~ GetPosition()
    }
    note right of Cat
        封装示意图：私有属性不可见，
        外部只能通过公有方法访问
    end note

该类图清晰展示了封装的效果：所有字段均被隐藏，外部只能通过两个公开方法进行交互。这种设计模式应贯穿于所有游戏角色类中，形成统一的编程规范。

2.1.2 继承：实现类之间的层次关系与代码复用

继承允许一个类（派生类）基于另一个类（基类）进行扩展，复用其已有属性和方法，同时可添加新的特性或覆盖原有行为。在游戏开发中，多个角色往往共享某些通用属性（如位置、生命值、绘制方法），此时可通过定义一个基类 GameObject ，让 Cat 、 Mouse 等具体角色继承它，避免重复编码。

class GameObject {
protected:
    int x, y;
    bool alive;

public:
    GameObject(int x, int y) : x(x), y(y), alive(true) {}
    virtual ~GameObject() = default;

    virtual void Update() = 0;  // 纯虚函数，强制子类实现
    virtual void Draw() = 0;

    void Kill() { alive = false; }
    bool IsAlive() const { return alive; }
    std::pair<int, int> GetPosition() const { return {x, y}; }
};

class Cat : public GameObject {
public:
    Cat(int x, int y) : GameObject(x, y) {}

    void Update() override {
        // AI 或玩家输入驱动移动
    }

    void Draw() override {
        std::cout << "C";
    }
};

class Mouse : public GameObject {
public:
    Mouse(int x, int y) : GameObject(x, y) {}

    void Update() override {
        // 随机移动逻辑
    }

    void Draw() override {
        std::cout << "M";
    }
};

在此结构中， GameObject 作为抽象基类，定义了所有游戏对象必须具备的基本行为（更新、绘制、存活状态）。 Cat 和 Mouse 无需重新定义 GetPosition() 或 IsAlive() ，直接继承即可使用。这极大提升了代码的 复用率 ，也方便后续统一管理所有对象。

逻辑分析：
- protected 关键字用于允许子类访问父类成员，但禁止外部访问，比 private 更适合继承场景。
- 构造函数初始化列表 : GameObject(x, y) 确保基类部分被正确构造。
- virtual void Update() = 0; 声明为纯虚函数，使 GameObject 成为抽象类，不能实例化，仅用于接口规范。

2.1.3 多态：同一接口不同实现，提升系统扩展性

多态是指“同一种接口表现出多种形态”的能力。在C++中，主要通过 虚函数+基类指针/引用 实现运行时多态。对于游戏主循环而言，这意味着可以用统一的方式处理不同类型的角色，而无需关心其具体类型。

考虑以下主循环片段：

std::vector<std::unique_ptr<GameObject>> objects;
objects.push_back(std::make_unique<Cat>(5, 5));
objects.push_back(std::make_unique<Mouse>(8, 8));

// 主循环
while (gameRunning) {
    for (auto& obj : objects) {
        obj->Update();  // 调用实际类型的Update()
        obj->Draw();    // 动态绑定到对应实现
    }
    Sleep(100);
}

尽管 obj 是 GameObject* 类型，但由于 Update() 和 Draw() 是虚函数，实际调用的是 Cat::Update() 或 Mouse::Draw() 。这就是 动态绑定 的体现。

调用形式 绑定时机 是否支持多态
非虚函数调用 编译期 否
虚函数调用（指针/引用） 运行期 是
对象值调用 编译期 否（会发生 slicing）

表格说明：只有通过指针或引用调用虚函数才能触发多态。若直接使用对象值（如 GameObject g = Cat(); g.Update(); ），会导致“对象切片”（slicing），丢失子类信息。

sequenceDiagram
    participant MainLoop
    participant GameObjectPtr
    participant Cat
    participant Mouse

    MainLoop->>GameObjectPtr: 遍历容器
    GameObjectPtr->>Cat: obj->Update()
    Cat-->>MainLoop: 执行追踪逻辑
    GameObjectPtr->>Mouse: obj->Update()
    Mouse-->>MainLoop: 执行逃逸逻辑
    Note right of MainLoop: 同一调用，不同行为

该序列图形象地展示了多态在游戏循环中的作用：主循环无需区分角色类型，只需调用统一接口，系统自动选择正确的实现。这种设计极大地简化了控制流程，并为将来扩展 Obstacle 、 SuperMouse 等新类型提供了无缝接入的能力。

综上所述，封装保障了数据安全，继承实现了代码复用，多态增强了系统灵活性。三者协同工作，构成了现代游戏引擎中“组件化”、“实体-系统”等高级架构的基础。掌握它们不仅是编写合格C++代码的前提，更是迈向专业级游戏开发的关键一步。

2.2 游戏角色抽象建模方法论

在进入具体编码之前，必须完成从现实需求到软件模型的转化过程，即 抽象建模 。这一阶段决定了整个系统的结构性质量。对于“猫抓老鼠”游戏，我们需要将直观的行为观察转化为精确的类结构设计，明确每个角色的属性、行为及其相互关系。这个过程不仅仅是技术实现，更是一种系统化思维训练。

2.2.1 从现实世界到类的设计：猫和老鼠的行为特征分析

首先需对目标对象进行行为拆解。猫的核心目标是“捕捉老鼠”，其典型行为包括：感知周围环境、朝目标方向移动、判定是否捕获成功。老鼠的目标则是“逃避追捕”，行为表现为：侦测威胁、随机或定向逃跑、尝试躲藏。两者虽均为“移动的生物”，但动机与策略截然不同。

进一步细化可得：
- 猫的行为模式 ：
- 主动搜索：即使无视觉线索，也会巡视地图。
- 目标导向：一旦发现老鼠，立即沿最短路径逼近。
- 捕获判定：当与老鼠处于同一格子时触发胜利条件。
- 老鼠的行为模式 ：
- 被动响应：多数时间随机游走，仅在接近猫时启动逃跑机制。
- 生存优先：倾向于远离高风险区域（如猫所在行列）。
- 状态切换：存在“静止—警觉—逃跑”三种状态。

这些行为差异提示我们：虽然二者均可视为“可移动实体”，但其更新逻辑（ Update() ）应各自独立实现。然而，它们又共享一些共通要素，如坐标、存活状态、图形表示等。这就引出了继承与多态的应用场景。

2.2.2 属性与行为的提取：位置、移动方式、状态变化

接下来进行属性与方法的提取。采用“名词→属性，动词→方法”的经典建模法则：

现实概念 抽象结果 类型 说明
位置 x, y 坐标 int 表示在二维网格中的行列索引
移动 Move() 方法 成员函数 改变当前位置
方向 direction char 或 enum ‘U’, ‘D’, ‘L’, ‘R’ 表示上下左右
生命状态 alive bool 标记是否被捕获或移除
速度 speed int 控制每帧移动步长（暂固定为1）
视野范围 viewRange int 决定能否感知到老鼠（猫专属）

行为方面， Move() 是最核心的方法。但对于猫和老鼠，其实现逻辑不同：
- Cat::Move() ：根据当前与老鼠的距离决定下一步方向，可用简单贪心算法实现（靠近目标）。
- Mouse::Move() ：大多数情况下随机选择方向，但在检测到猫接近时切换为反向逃离。

此外，还需定义事件响应方法，如 OnDetectedThreat() 、 OnCaught() 等，用于处理状态变更。这些方法可在基类中声明为虚函数，供子类重写。

2.2.3 类图设计与UML初步应用

为了可视化类结构关系，采用UML（Unified Modeling Language）类图进行建模。以下是“猫抓老鼠”游戏的初步类图设计：

classDiagram
    class GameObject {
        +<<abstract>>
        -int x
        -int y
        -bool alive
        +GameObject(int, int)
        +virtual ~GameObject()
        +virtual void Update()*
        +virtual void Draw()* 
        +void Kill()
        +bool IsAlive()
        +pair~int,int~ GetPosition()
    }

    class Cat {
        -int viewRange
        -char lastDirection
        +Cat(int, int)
        +void Update() override
        +void Draw() override
        +bool CanSee(const Mouse&) 
    }

    class Mouse {
        -enum State { IDLE, FLEEING }
        -State state
        +Mouse(int, int)
        +void Update() override
        +void Draw() override
        +void FleeFrom(const Cat&)
    }

    GameObject <|-- Cat
    GameObject <|-- Mouse

该图展示了以下关键设计决策：
- GameObject 为抽象基类，包含所有公共属性和接口。
- Cat 和 Mouse 继承自 GameObject ，各自扩展专有属性和方法。
- Update() 和 Draw() 为纯虚函数，强制子类实现差异化逻辑。
- 关联关系未显式画出，但在 CanSee() 中隐含了对 Mouse 的引用依赖。

此模型具备良好扩展性：未来若增加 Obstacle 类，只需继承 GameObject 并实现 Draw() 即可纳入主循环；若要引入 SuperMouse 拥有隐身能力，可通过再继承 Mouse 类并重写 Update() 来实现。

综上，抽象建模不仅是画图的过程，更是梳理业务逻辑、识别共性与差异、预判演进方向的战略性活动。唯有如此，才能构建出既满足当前需求又不失灵活性的高质量软件架构。

3. Cat类与Mouse类的封装实现

在“猫抓老鼠”小游戏的设计中，角色行为的抽象与封装是整个系统架构的核心。C++作为一门支持面向对象特性的语言，提供了强大的机制来组织复杂逻辑。本章将围绕 Cat 和 Mouse 两个核心游戏角色展开详细设计，重点阐述如何通过类的封装实现数据隐藏、行为抽象以及职责分离。通过对私有属性管理、公共接口暴露、成员函数实现等手段，构建出高内聚、低耦合的游戏实体模型。此外，还将深入探讨头文件与源文件的合理组织方式，并引入容器技术对多个游戏对象进行统一管理，为后续扩展多只猫或群鼠场景奠定基础。

3.1 Cat类的设计与成员实现

Cat 类代表游戏中主动追捕的一方，其行为不仅受玩家控制（可选），也可由AI算法驱动。为了保证代码结构清晰且易于维护，必须从现实世界中的猫的行为特征出发，提炼出关键状态和动作，进而映射为类的属性和方法。

3.1.1 私有属性定义：坐标(x,y)、速度、方向

一个合理的 Cat 类应当包含描述其当前状态的基本属性。这些信息应被设为私有成员，防止外部直接修改，从而提升程序的安全性和稳定性。

class Cat {
private:
    int x, y;           // 当前位置坐标
    int speed;          // 移动速度（每步移动格数）
    char direction;     // 当前移动方向：'U'(上), 'D'(下), 'L'(左), 'R'(右)
    bool isAlive;       // 是否存活（用于未来扩展受伤/死亡状态）

public:
    Cat(int startX, int startY);  // 构造函数
    void Move();                  // 移动方法
    void SetDirection(char dir);  // 设置方向
    std::pair<int, int> GetPosition() const; // 获取位置
    void SetPosition(int newX, int newY);    // 设置位置
};

上述代码展示了 Cat 类的基本框架。其中：

  • x , y 表示在二维地图上的整数坐标；
  • speed 虽然在此版本中固定为1，但预留字段便于后期加速道具扩展；
  • direction 使用字符类型简化输入处理；
  • isAlive 是布尔标志位，可用于实现受伤后暂停移动等功能。

使用 private 关键字确保这些状态只能通过类提供的接口访问或修改，符合封装原则。

成员变量 类型 初始值 说明
x int 参数传入 横坐标
y int 参数传入 纵坐标
speed int 1 固定步长
direction char ‘R’ 默认向右
isAlive bool true 初始存活

该表格明确列出了各属性的语义含义与默认设定，有助于团队协作开发时保持一致性。

3.1.2 公共方法设计：Move()、GetPosition()、SetPosition()

公开接口的设计需遵循最小权限原则——仅暴露必要的功能。以下是几个关键方法的实现示例：

// 获取当前位置（常量成员函数，不改变对象状态）
std::pair<int, int> Cat::GetPosition() const {
    return std::make_pair(x, y);
}

// 设置新位置
void Cat::SetPosition(int newX, int newY) {
    x = newX;
    y = newY;
}

// 根据方向移动一步
void Cat::Move() {
    if (!isAlive) return;  // 死亡状态不可移动

    switch (direction) {
        case 'U': y--; break;
        case 'D': y++; break;
        case 'L': x--; break;
        case 'R': x++; break;
        default: break;  // 无效方向不做操作
    }
}

逐行解析：

  • std::pair<int, int> 返回两个坐标的组合，避免多次调用 getter。
  • const 修饰 GetPosition() 表明该函数不会修改对象状态，增强安全性。
  • SetPosition() 提供直接赋值能力，适用于初始化或重置位置。
  • Move() 中先判断 isAlive ，体现状态控制逻辑；随后根据方向更新坐标。

此设计使得外部模块无需了解内部存储细节即可完成交互，如主循环可通过 cat.Move() 触发位移，而无需关心具体算法。

3.1.3 行为逻辑封装：自动追踪算法初步实现

为进一步增强 Cat 的智能性，可在 Move() 基础上扩展自动追踪功能。假设已知老鼠的位置 (mouseX, mouseY) ，可基于欧几里得距离选择最优方向逼近目标。

void Cat::AutoTrack(int mouseX, int mouseY) {
    int dx = mouseX - x;
    int dy = mouseY - y;

    // 优先水平或垂直靠近
    if (abs(dx) > abs(dy)) {
        direction = (dx > 0) ? 'R' : 'L';
    } else {
        direction = (dy > 0) ? 'D' : 'U';
    }

    Move();  // 执行移动
}

参数说明：

  • mouseX , mouseY ：传入当前鼠标位置，通常由主循环传递。
  • dx , dy ：计算相对偏移量。
  • abs() 来自 <cstdlib> ，用于比较绝对值大小，决定优先轴向。

该策略采用贪心法，在每帧选择最接近目标的方向前进，虽非全局最优路径，但在简单网格环境中表现良好。

graph TD
    A[开始自动追踪] --> B{是否活着?}
    B -- 否 --> C[停止移动]
    B -- 是 --> D[获取老鼠坐标]
    D --> E[计算dx, dy]
    E --> F{abs(dx) > abs(dy)?}
    F -- 是 --> G[水平移动: R/L]
    F -- 否 --> H[垂直移动: U/D]
    G --> I[调用Move()]
    H --> I
    I --> J[结束]

流程图清晰表达了 AutoTrack() 方法的执行逻辑分支，有助于理解条件判断顺序及最终行为输出。

3.2 Mouse类的设计与行为模拟

与 Cat 不同， Mouse 通常是被动角色，以逃避为主要目标。它的行为更具随机性和反应性，因此需要更复杂的决策机制来模拟“逃逸本能”。

3.2.1 随机移动策略的实现原理

为了让 Mouse 显得“自然”，不能让它总是直线逃跑。我们采用伪随机方式生成下一步方向，同时引入概率权重偏向远离 Cat 的方向。

#include <random>
#include <vector>

class Mouse {
private:
    int x, y;
    bool isEscaping;
    static std::mt19937 rng;  // Mersenne Twister 随机引擎

public:
    Mouse(int startX, int startY);
    void RandomMove();
    void FleeFrom(int catX, int catY);
    std::pair<int, int> GetPosition() const;
    void SetPosition(int nx, int ny);
    bool IsCaughtBy(int cx, int cy) const;
};

这里使用静态成员 rng 保证整个程序范围内共享同一个高质量随机源，避免频繁初始化带来的性能损耗。

// 初始化静态随机引擎
std::mt19937 Mouse::rng(std::chrono::steady_clock::now().time_since_epoch().count());

void Mouse::RandomMove() {
    std::uniform_int_distribution<int> dist(0, 3);
    int choice = dist(rng);
    int dx[] = {0, 0, -1, 1};  // 上、下、左、右
    int dy[] = {-1, 1, 0, 0};

    x += dx[choice];
    y += dy[choice];
}

逻辑分析：

  • std::mt19937 是现代C++推荐的随机数生成器，比 rand() 更均匀。
  • std::uniform_int_distribution 确保每个方向概率相等。
  • time_since_epoch().count() 作为种子，防止每次运行结果相同。

尽管这是纯随机移动，但可用于基础版本测试。

3.2.2 逃逸行为的状态控制（静止/逃跑）

引入状态变量 isEscaping 可使 Mouse 在感知威胁时切换行为模式。例如当 Cat 进入一定范围（如3格以内）时进入“逃跑”状态，否则自由漫游。

void Mouse::FleeFrom(int catX, int catY) {
    int distSq = (x - catX)*(x - catX) + (y - catY)*(y - catY);
    if (distSq < 9) {  // 距离小于3
        isEscaping = true;
        Evade(catX, catY);
    } else {
        isEscaping = false;
        RandomMove();
    }
}

void Mouse::Evade(int cx, int cy) {
    int bestScore = -1;
    int bestDx = 0, bestDy = 0;

    for (int dx = -1; dx <= 1; ++dx) {
        for (int dy = -1; dy <= 1; ++dy) {
            if (dx == 0 && dy == 0) continue;
            int nx = x + dx, ny = y + dy;
            int score = (nx - cx)*(nx - cx) + (ny - cy)*(ny - cy); // 到猫的距离平方
            if (score > bestScore) {
                bestScore = score;
                bestDx = dx;
                bestDy = dy;
            }
        }
    }
    x += bestDx;
    y += bestDy;
}

此段代码实现了简单的反向寻路：枚举四个相邻方向，选择使与 Cat 距离最大的那个。虽然未考虑障碍物，但已具备基本智能响应能力。

3.2.3 与Cat的距离感知机制

IsCaughtBy() 方法用于检测是否被捕获，即两者坐标是否重合：

bool Mouse::IsCaughtBy(int cx, int cy) const {
    return (x == cx && y == cy);
}

这个轻量级判断将在主循环中频繁调用，因此必须高效。也可以扩展为检测曼哈顿距离 ≤1 来模拟“接触”而非完全重叠。

下面是一个综合行为决策的表格：

当前状态 检测到Cat距离 行为选择 实现方法
自由漫游 ≥3格 随机移动 RandomMove()
感知威胁 <3格 主动远离 Evade()
被捕获 坐标重合 触发游戏结束 外部调用判定

该表帮助开发者快速定位不同情境下的行为映射关系，提高调试效率。

3.3 成员函数的分离编译与头文件组织

随着项目规模扩大，所有代码写在一个 .cpp 文件中会变得难以维护。C++ 支持声明与实现分离，即将类定义放在头文件 .h ，实现放在 .cpp 。

3.3.1 .h与.cpp文件的分工协作

创建 Cat.h ：

// Cat.h
#ifndef CAT_H
#define CAT_H

#include <utility>

class Cat {
private:
    int x, y;
    int speed;
    char direction;
    bool isAlive;

public:
    Cat(int startX, int startY);
    void Move();
    void AutoTrack(int mouseX, int mouseY);
    void SetDirection(char dir);
    std::pair<int, int> GetPosition() const;
    void SetPosition(int x, int y);
};

#endif // CAT_H

对应 Cat.cpp ：

// Cat.cpp
#include "Cat.h"
#include <cmath>

Cat::Cat(int startX, int startY) 
    : x(startX), y(startY), speed(1), direction('R'), isAlive(true) {}

void Cat::Move() {
    if (!isAlive) return;
    switch (direction) {
        case 'U': y--; break;
        case 'D': y++; break;
        case 'L': x--; break;
        case 'R': x++; break;
    }
}

void Cat::AutoTrack(int mouseX, int mouseY) {
    int dx = mouseX - x;
    int dy = mouseY - y;
    if (std::abs(dx) >= std::abs(dy)) {
        direction = (dx > 0) ? 'R' : 'L';
    } else {
        direction = (dy > 0) ? 'D' : 'U';
    }
    Move();
}

这种分离带来以下优势：

  • 编译解耦 ：修改 .cpp 不影响其他文件重新编译；
  • 接口稳定 ： .h 文件对外暴露契约，内部实现可变；
  • 团队协作友好 ：多人并行开发不同模块。

3.3.2 防止头文件重复包含的预处理指令

使用 #ifndef / #define / #endif 守护宏防止多次包含导致重定义错误。现代编译器也支持 #pragma once ，但标准兼容性略差。

#ifndef MOUSE_H
#define MOUSE_H

#include <utility>

class Mouse {
private:
    int x, y;
    bool isEscaping;
    static std::mt19937 rng;

public:
    Mouse(int x, int y);
    void RandomMove();
    void FleeFrom(int cx, int cy);
    std::pair<int, int> GetPosition() const;
    bool IsCaughtBy(int cx, int cy) const;
    void SetPosition(int nx, int ny);
};

#endif

若遗漏此机制，当多个头文件互相引用时极易引发编译错误。

3.4 类实例化与对象数组管理多个角色

在实际游戏中，往往不止一只猫或一只老鼠。使用动态内存或STL容器能灵活管理对象集合。

3.4.1 动态创建游戏角色（new/delete）

Cat* cat = new Cat(5, 5);
Mouse* mouse = new Mouse(10, 10);

// 游戏结束后释放资源
delete cat;
delete mouse;

虽然可行，但手动管理易造成内存泄漏。建议配合智能指针（如 std::unique_ptr ）使用。

3.4.2 使用vector容器管理Cat与Mouse对象集合

更优方案是使用 std::vector 存储对象指针或值：

#include <vector>
#include <memory>

std::vector<std::unique_ptr<Cat>> cats;
std::vector<Mouse> mice;

// 添加三只猫
for (int i = 0; i < 3; ++i) {
    cats.emplace_back(std::make_unique<Cat>(i+1, i+1));
}

// 添加五只老鼠
for (int i = 0; i < 5; ++i) {
    mice.emplace_back(15-i, 15-i);
}

// 统一更新
for (auto& cat : cats) {
    cat->AutoTrack(mice[0].GetPosition().first, mice[0].GetPosition().second);
}

优点：

  • 自动扩容；
  • RAII 管理生命周期；
  • 支持迭代器遍历；
  • 与算法库无缝集成。
classDiagram
    class Cat {
        -int x
        -int y
        -char direction
        +Move()
        +AutoTrack(int,int)
        +GetPosition() pair~int,int~
    }
    class Mouse {
        -int x
        -int y
        -bool isEscaping
        +RandomMove()
        +FleeFrom(int,int)
        +IsCaughtBy(int,int) bool
    }
    Cat ..> Mouse : 追踪

类图展示了 Cat 与 Mouse 之间的依赖关系，体现了高阶设计视角。

综上所述，通过精细化的封装、合理的文件组织与高效的对象管理， Cat 与 Mouse 类已成为可复用、可扩展的游戏组件，为后续继承与多态打下坚实基础。

4. 继承与多态在游戏角色扩展中的高级应用

在现代游戏开发中，随着角色种类的增多和行为逻辑的复杂化，单一的类设计已无法满足可维护性与扩展性的需求。通过引入面向对象的核心机制—— 继承与多态 ，我们能够构建出高度模块化、易于拓展的游戏架构。本章将围绕“猫抓老鼠”小游戏的实际场景，深入探讨如何利用基类抽象、虚函数机制以及动态绑定技术，实现对游戏角色的统一管理与灵活扩展。重点在于展示从具体实现向通用框架演进的设计思维，并通过代码实例揭示底层运行机制。

4.1 基类GameObject的抽象设计

为了统一管理所有出现在游戏世界中的实体（如猫、老鼠、障碍物等），我们需要定义一个通用的基类 GameObject 。该类不直接用于实例化对象，而是作为其他具体角色类的公共父类，提供一组标准化的接口方法。这种设计模式被称为 抽象基类（Abstract Base Class, ABC） ，其核心思想是将共通的行为协议提取出来，交由子类按需实现。

4.1.1 定义通用接口：Update()、Draw()、IsAlive()

在一个典型的游戏主循环中，每一帧都需要完成三项基本任务：更新状态、绘制画面、判断存活。因此，我们将这三个操作抽象为纯虚函数，强制所有派生类必须实现它们：

// GameObject.h
#ifndef GAMEOBJECT_H
#define GAMEOBJECT_H

#include <iostream>

class GameObject {
public:
    virtual ~GameObject() = default;                    // 虚析构函数（见4.4节）
    virtual void Update() = 0;                          // 更新逻辑（移动、AI等）
    virtual void Draw() const = 0;                      // 绘制自身到屏幕
    virtual bool IsAlive() const = 0;                   // 判断是否存活
    virtual int GetX() const = 0;                       // 获取X坐标
    virtual int GetY() const = 0;                       // 获取Y坐标
};

#endif // GAMEOBJECT_H

上述代码中，每个成员函数都被声明为 纯虚函数（ = 0 ） ，意味着 GameObject 是一个不能被实例化的抽象类。任何试图创建 GameObject obj; 的行为都会导致编译错误。

代码逻辑逐行解读：
  • 第7行：使用预处理指令防止头文件重复包含。
  • 第12行：声明虚析构函数并设为默认实现。这是关键安全措施，确保通过基类指针删除派生类对象时能正确调用析构函数（详见4.4节）。
  • 第15–19行：五个纯虚函数构成了一套完整的交互契约。例如：
  • Update() 可用于处理移动、碰撞响应或AI决策；
  • Draw() 在控制台中可能输出字符符号，在图形引擎中则触发渲染命令；
  • IsAlive() 支持游戏逻辑判断（如老鼠被捕后应标记为死亡）；
  • GetX()/GetY() 提供位置访问能力，便于进行距离计算或地图绘制。

这些接口构成了未来所有游戏对象必须遵循的规范，使得上层逻辑可以无视具体类型而统一操作。

4.1.2 纯虚函数与抽象类的使用场景

抽象类的本质是一种“设计蓝图”，它不关心细节实现，只关注接口一致性。在游戏开发中，以下几种情况特别适合使用抽象类：

使用场景 说明
多种角色共享相同生命周期管理 如 Cat、Mouse、Obstacle 都需要每帧更新和绘制
需要统一容器存储不同类型对象 使用 std::vector<GameObject*> 存储所有活动对象
接口稳定但实现差异大 所有对象都有 Draw() 方法，但猫画 ‘C’，老鼠画 ‘M’
防止误实例化基础类型 GameObject 本身不代表任何实际存在

下面是一个基于此抽象类的 UML 类图，使用 Mermaid 格式表示：

classDiagram
    class GameObject {
        <<abstract>>
        +virtual ~GameObject()
        +virtual void Update()*
        +virtual void Draw()* const
        +virtual bool IsAlive()* const
        +virtual int GetX()* const
        +virtual int GetY()* const
    }

    class Cat {
        -int x, y
        -bool alive
        +Update()
        +Draw() const
        +IsAlive() const
        +GetX() const
        +GetY() const
    }

    class Mouse {
        -int x, y
        -bool alive
        +Update()
        +Draw() const
        +IsAlive() const
        +GetX() const
        +GetY() const
    }

    GameObject <|-- Cat
    GameObject <|-- Mouse

流程图说明 ：
上图展示了 GameObject 作为抽象基类，被 Cat 和 Mouse 两个具体类继承的关系。箭头方向表示“继承自”。 <<abstract>> 表示此类不可实例化。所有带 * 的方法均为纯虚函数，子类必须重写。

这种结构极大提升了系统的可扩展性。当未来需要添加 SuperMouse 或 Trap 等新角色时，只需继承 GameObject 并实现相应方法即可无缝接入现有系统。

此外，抽象类还支持 依赖倒置原则（DIP） ——高层模块（如游戏主循环）依赖于抽象，而非具体实现。这正是实现松耦合的关键所在。

4.2 Cat与Mouse对基类的继承实现

在定义了统一的抽象接口之后，下一步是让具体的 Cat 和 Mouse 类继承 GameObject 并实现各自的业务逻辑。这一过程不仅体现了封装性，更重要的是开启了多态调用的可能性。

4.2.1 重写虚函数以实现差异化行为

以下是 Cat 类继承自 GameObject 的完整实现示例：

// Cat.h
#ifndef CAT_H
#define CAT_H

#include "GameObject.h"

class Cat : public GameObject {
private:
    int x, y;
    bool alive;

public:
    Cat(int startX = 0, int startY = 0);
    ~Cat() override = default;

    void Update() override;
    void Draw() const override;
    bool IsAlive() const override;
    int GetX() const override;
    int GetY() const override;

    void SetPosition(int newX, int newY);
};

#endif // CAT_H

// Cat.cpp
#include "Cat.h"
#include <iostream>

Cat::Cat(int startX, int startY) : x(startX), y(startY), alive(true) {}

void Cat::Update() {
    // 示例：AI自动向右移动（真实游戏中会结合玩家输入或路径寻路）
    if (alive) {
        x = (x + 1) % 20;  // 地图宽20格，循环边界
    }
}

void Cat::Draw() const {
    std::cout << 'C';
}

bool Cat::IsAlive() const {
    return alive;
}

int Cat::GetX() const {
    return x;
}

int Cat::GetY() const {
    return y;
}

void Cat::SetPosition(int newX, int newY) {
    x = newX;
    y = newY;
}
参数说明与逻辑分析：
  • 构造函数接受初始坐标，默认值为 (0, 0) ，便于测试；
  • Update() 模拟简单AI行为：每帧向右移动一格，到达边缘后回卷；
  • Draw() 输出字符 'C' ，可在二维地图中标识位置；
  • 所有方法均使用 override 关键字显式声明覆盖关系，增强代码可读性和安全性；
  • SetPosition() 是额外提供的非虚函数，供外部控制系统直接设置位置（如重置游戏时）；

同理， Mouse 类也实现了相同的接口，但行为不同：

// Mouse.cpp（部分）
void Mouse::Update() {
    // 随机移动策略（简化版）
    static int step = 0;
    step++;
    if (step % 3 == 0 && alive) {  // 每3帧移动一次
        int dx = rand() % 3 - 1;   // -1, 0, 1
        int dy = rand() % 3 - 1;
        x = std::max(0, std::min(19, x + dx));  // 边界限制
        y = std::max(0, std::min(19, y + dy));
    }
}

这里的 Update() 实现了周期性随机走动，模拟老鼠逃逸行为。虽然与 Cat 的移动方式完全不同，但由于都继承自 GameObject ，因此可以在同一集合中被统一调度。

4.2.2 多态调用在主循环中的统一处理

借助多态机制，我们可以使用基类指针数组来管理所有角色，从而实现“一次遍历，多种行为”的高效控制流。

// main.cpp 片段
#include <vector>
#include "Cat.h"
#include "Mouse.h"

int main() {
    std::vector<GameObject*> gameObjects;
    Cat* cat = new Cat(5, 5);
    Mouse* mouse = new Mouse(10, 10);

    gameObjects.push_back(cat);
    gameObjects.push_back(mouse);

    while (true) {
        // 输入处理...

        // 更新阶段：多态调用
        for (auto obj : gameObjects) {
            obj->Update();  // 动态绑定到实际类型的Update()
        }

        // 渲染阶段
        for (int i = 0; i < 20; ++i) {
            for (int j = 0; j < 20; ++j) {
                bool drawn = false;
                for (auto obj : gameObjects) {
                    if (obj->GetX() == j && obj->GetY() == i) {
                        obj->Draw();
                        drawn = true;
                        break;
                    }
                }
                if (!drawn) std::cout << '.';
                else std::cout << ' ';
            }
            std::cout << '\n';
        }

        // Sleep(100); 控制帧率
    }

    // 清理资源...
    return 0;
}
多态执行机制详解：
  • 当调用 obj->Update() 时，编译器生成的是 虚函数表（vtable）查找指令 ；
  • 运行时根据指针指向的实际对象类型决定调用哪个版本的 Update() ；
  • 即使 obj 是 GameObject* 类型，也能正确调用 Cat::Update() 或 Mouse::Update() ；
  • 这种机制称为 动态绑定（Dynamic Binding） ，是多态的核心支撑。

这种方式彻底解耦了主循环与具体角色类型之间的依赖关系，极大增强了系统的可维护性与可扩展性。

4.3 扩展更多游戏角色类型

一旦建立了基于抽象基类的架构，新增角色变得异常简单。无论是静态障碍物还是特殊能力单位，都可以通过继承轻松集成。

4.3.1 派生子类Obstacle、SuperMouse示例

Obstacle 类（不可移动的障碍）
// Obstacle.h
class Obstacle : public GameObject {
private:
    int x, y;
    bool visible;

public:
    Obstacle(int x, int y) : x(x), y(y), visible(true) {}

    void Update() override {}
    void Draw() const override {
        if (visible) std::cout << '#';  // 障碍物用井号表示
    }
    bool IsAlive() const override { return visible; }
    int GetX() const override { return x; }
    int GetY() const override { return y; }
};

Obstacle 的 Update() 为空，因为它不需要动作更新，但依然符合接口要求。

SuperMouse 类（具备加速能力）
// SuperMouse.h
class SuperMouse : public Mouse {
private:
    int speedBoostTimer;

public:
    SuperMouse(int x, int y) : Mouse(x, y), speedBoostTimer(0) {}

    void Update() override {
        if (speedBoostTimer > 0) {
            // 每帧移动两次
            Mouse::Update();
            Mouse::Update();
            speedBoostTimer--;
        } else {
            Mouse::Update();  // 正常速度
        }

        // 每30秒获得一次加速机会（模拟道具效果）
        static int globalTime = 0;
        globalTime++;
        if (globalTime % 300 == 0) {  // 假设每帧100ms
            speedBoostTimer = 5;
        }
    }

    void Draw() const override {
        std::cout << 'S';  // 用'S'表示超级老鼠
    }
};

这里利用了 继承+增强 的方式，在保留原有 Mouse 行为的基础上增加了加速功能。

4.3.2 不同角色间的交互规则设计

随着角色类型的增加，交互逻辑也需要规范化。可以通过定义简单的规则表来管理行为影响：

主动方 \ 被动方 Cat Mouse Obstacle SuperMouse
Cat — 触发捕获 无法穿越 触发捕获（失败概率30%）
Mouse 逃跑 — 避开 合作逃脱（概率提升）
Obstacle 阻挡 阻挡 — 阻挡
SuperMouse 有50%概率逃脱 — 可短暂穿透 —

这类表格可用于指导碰撞检测后的逻辑分支编写，例如：

if (dynamic_cast<Cat*>(attacker) && dynamic_cast<Mouse*>(target)) {
    if (rand() % 100 < 30 && target->is<SuperMouse>()) {
        std::cout << "SuperMouse escaped!\n";
    } else {
        target->setAlive(false);
    }
}

动态类型识别（ dynamic_cast ）结合条件判断，实现了基于角色身份的差异化反应。

4.4 虚析构函数的重要性与内存泄漏防范

尽管多态带来了极大的灵活性，但也伴随着资源管理的风险。若未正确处理对象销毁，极易引发 内存泄漏 或 未定义行为 。

4.4.1 delete父类指针时的正确资源释放

考虑如下代码片段：

GameObject* obj = new Cat(1, 1);
delete obj;  // ❌ 危险！如果~GameObject()不是虚函数

如果没有将 ~GameObject() 声明为虚函数，那么 delete 将只会调用 GameObject 的析构函数，而不会调用 Cat 的析构函数。这意味着即使 Cat 中分配了资源（如动态数组、文件句柄），也无法得到释放。

解决办法是 在基类中声明虚析构函数 ：

virtual ~GameObject() = default;

此时， delete obj; 会触发动态绑定，先调用 Cat::~Cat() ，再调用 ~GameObject() ，保证完整清理链。

虚析构函数工作原理（vptr/vtable机制）：
// 内存布局示意（简略）
[ vptr → 指向 Cat_vtable ]
[ int x ]
[ int y ]
[ bool alive ]
  • 每个对象包含一个隐藏的 vptr （虚表指针），指向所属类的虚函数表；
  • delete 时通过 vptr 查找正确的析构函数地址；
  • 因此必须启用 RTTI（Run-Time Type Information）机制；

4.4.2 RAII原则在游戏对象管理中的体现

为了避免手动 new/delete 导致的资源泄露风险，推荐采用 RAII（Resource Acquisition Is Initialization） 原则，结合智能指针自动管理生命周期。

#include <memory>
#include <vector>

std::vector<std::unique_ptr<GameObject>> gameObjects;

gameObjects.emplace_back(std::make_unique<Cat>(5, 5));
gameObjects.emplace_back(std::make_unique<Mouse>(10, 10));

// 无需手动delete，离开作用域自动释放

std::unique_ptr 确保独占所有权，且能正确调用虚析构函数。即使发生异常抛出，也能保证资源释放。

此外，还可使用 std::shared_ptr 实现共享所有权（如多个陷阱引用同一个特效资源），进一步提升灵活性。

综上所述，通过合理运用继承与多态机制，我们不仅能实现角色行为的多样化表达，还能建立一个高度内聚、低耦合的游戏对象管理体系。从抽象基类的设计到派生类的实现，再到多态调用与资源安全管理，整个流程展现了 C++ 面向对象编程的强大表现力与工程价值。

5. 游戏初始化与二维场景构建

在现代游戏开发中，一个清晰、可扩展的初始化流程和合理的场景结构是确保程序稳定运行与后续功能拓展的基础。对于基于控制台的“猫抓老鼠”小游戏而言，虽然没有复杂的图形渲染引擎支持，但依然需要构建一套完整的二维空间模型来模拟真实的游戏世界。本章将深入探讨如何从零开始搭建游戏的核心框架——包括地图坐标系的设计、角色初始位置的智能生成、可视化字符界面的实现以及全局状态的有效管理。这些内容不仅是游戏启动阶段的关键步骤，也为后续主循环逻辑提供了数据支撑和交互基础。

通过合理使用C++语言特性与标准库工具，我们将构建出一个模块化、易于维护的游戏初始化系统。整个过程不仅涉及基础的数据结构设计（如二维数组），还融合了随机数生成算法、跨平台兼容性处理、内存布局优化等工程实践问题。尤其值得注意的是，在资源受限或调试环境下，基于文本的图形化显示方案仍然具有极高的实用价值，它使得开发者能够在不依赖外部库的情况下快速验证核心逻辑。

更重要的是，这一阶段所建立的结构直接影响到游戏的可扩展性。例如，未来若要引入障碍物、多个老鼠或动态地形变化等功能，都必须依托于当前构建的二维网格体系。因此，本章内容不仅是技术实现的起点，更是设计理念的一次集中体现：即如何在有限的技术条件下，通过抽象建模与分层设计，为复杂系统打下坚实基础。

5.1 游戏地图的坐标系设定

游戏世界的本质是一个被规则约束的空间模型，而坐标系正是描述这个空间的基本数学工具。在“猫抓老鼠”这类基于网格的小游戏中，采用离散化的二维坐标系统是最自然且高效的选择。该系统以行和列的形式组织地图单元，每个单元对应屏幕上的一个可视格子，通常用于表示空地、角色、障碍物或其他特殊元素。这种设计不仅简化了位置计算与碰撞检测，也便于后期进行路径规划与AI决策。

5.1.1 使用二维数组表示游戏网格

最直观的地图表示方式是使用二维数组 char map[ROWS][COLS] 或 std::vector<std::vector<char>> 来存储每个格子的状态。前者适用于固定大小的地图，后者则更适合动态调整尺寸的场景。以下是一个典型的地图定义示例：

#include <vector>

const int MAP_HEIGHT = 10;
const int MAP_WIDTH  = 20;

// 方法一：静态二维数组
char gameMap[MAP_HEIGHT][MAP_WIDTH];

// 方法二：动态二维向量（推荐用于可变尺寸）
std::vector<std::vector<char>> CreateMap(int height, int width) {
    return std::vector<std::vector<char>>(height, std::vector<char>(width, '.'));
}

上述代码中， CreateMap 函数返回一个初始化为 '.' （代表空地）的二维向量。该设计具备良好的封装性和灵活性，允许在不同关卡中创建不同尺寸的地图。

表示符号 含义 数据类型 示例值
'.' 可行走空地 char ’.’
'C' 猫的位置 char ‘C’
'M' 老鼠的位置 char ‘M’
'#' 障碍物（预留扩展） char ’#’

该表格展示了地图中各字符的语义映射关系，构成了视觉与逻辑之间的桥梁。通过这种方式，我们可以在不修改底层逻辑的前提下，仅改变绘制符号即可完成外观调整。

下面是一个完整的地图初始化函数，结合了清空与边界设置的功能：

void InitializeMap(std::vector<std::vector<char>>& map) {
    const int h = map.size();
    const int w = map[0].size();

    // 初始化所有格子为空地
    for (int i = 0; i < h; ++i) {
        for (int j = 0; j < w; ++j) {
            map[i][j] = '.';
        }
    }

    // 设置四周边界为不可通行（可选）
    for (int i = 0; i < h; ++i) {
        map[i][0] = '#';           // 左边框
        map[i][w - 1] = '#';       // 右边框
    }
    for (int j = 0; j < w; ++j) {
        map[0][j] = '#';           // 上边框
        map[h - 1][j] = '#';       // 下边框
    }
}

逐行逻辑分析：

  • 第4~5行：获取地图的实际高度与宽度，避免硬编码。
  • 第8~13行：双重循环遍历所有格子，统一赋值为 '.' ，确保地图初始状态干净。
  • 第16~23行：分别对左右两侧列和上下两侧行设置为 '#' ，形成封闭边界。这一步可根据需求选择是否启用。

此函数体现了高内聚低耦合的设计思想——只负责地图状态的初始化，不涉及角色放置或用户输入，符合单一职责原则。

5.1.2 地图边界与可行走区域定义

为了防止游戏角色越界访问数组导致未定义行为（如段错误），必须明确界定合法的移动范围。一般做法是在每次移动前进行坐标合法性检查：

bool IsValidPosition(int x, int y, const std::vector<std::vector<char>>& map) {
    return x >= 0 && x < static_cast<int>(map[0].size()) &&
           y >= 0 && y < static_cast<int>(map.size()) &&
           map[y][x] != '#';  // 不是障碍物
}

该函数返回布尔值，判断 (x, y) 是否处于有效区域内。其中：
- x 和 y 分别代表列和行索引；
- map[y][x] != '#' 表示不能进入障碍格；
- 类型转换 static_cast<int> 是为了避免无符号整型比较带来的警告。

此外，可以借助 Mermaid 流程图 来可视化地图初始化的整体流程：

graph TD
    A[开始游戏初始化] --> B{创建地图容器}
    B --> C[分配 ROWS × COLS 空间]
    C --> D[填充默认字符 '.']
    D --> E[可选: 添加边界 '#']
    E --> F[调用 InitializeMap()]
    F --> G[生成角色初始位置]
    G --> H[进入主循环]

该流程图清晰地表达了从内存分配到地图准备的完整链条，有助于团队协作时理解模块依赖关系。同时，也为后续添加新功能（如加载地图文件）提供了扩展接口。

5.2 角色初始位置随机生成算法

为了让每局游戏体验更具随机性和挑战性，角色的起始位置不应固定不变。为此，需实现一套安全可靠的随机初始化机制，既能保证位置分布均匀，又能避免角色重叠或生成在障碍物上。

5.2.1 利用srand()与rand()设置种子与范围

C++ 标准库 <cstdlib> 提供了 rand() 和 srand() 函数用于生成伪随机数。正确使用它们的关键在于初始化随机种子：

#include <cstdlib>
#include <ctime>

void SeedRandom() {
    srand(static_cast<unsigned int>(time(nullptr)));
}

int RandomInRange(int min, int max) {
    return min + rand() % (max - min + 1);
}
  • SeedRandom() 应在程序启动时调用一次，利用当前时间作为种子，确保每次运行结果不同。
  • RandomInRange(min, max) 封装了常见范围生成逻辑，避免重复编写 % 运算。

然而， rand() 存在分布不均、周期短等问题。更优替代方案是使用 C++11 的 <random> 库：

#include <random>

std::random_device rd;  // 真实随机设备（非必须）
std::mt19937 gen(rd());
std::uniform_int_distribution<> dis_x(1, MAP_WIDTH - 2);
std::uniform_int_distribution<> dis_y(1, MAP_HEIGHT - 2);

int x = dis_x(gen);
int y = dis_y(gen);

此方法基于梅森旋转算法（Mersenne Twister），提供高质量随机数，适合长期运行的游戏系统。

5.2.2 避免角色重叠的初始化策略

最简单的防重叠策略是“重试法”：先随机生成猫的位置，再不断尝试生成老鼠的位置，直到两者不重合为止。

struct Position {
    int x, y;
};

Position GenerateUniquePosition(
    const std::vector<std::vector<char>>& map,
    const std::vector<Position>& occupied
) {
    int max_attempts = 100;
    for (int i = 0; i < max_attempts; ++i) {
        int x = RandomInRange(1, MAP_WIDTH - 2);
        int y = RandomInRange(1, MAP_HEIGHT - 2);

        bool is_occupied = false;
        for (const auto& pos : occupied) {
            if (pos.x == x && pos.y == y) {
                is_occupied = true;
                break;
            }
        }

        if (!is_occupied && map[y][x] == '.') {
            return {x, y};
        }
    }

    // 失败回退：返回中心附近位置
    return {MAP_WIDTH / 2, MAP_HEIGHT / 2};
}

参数说明：
- map ：当前地图，用于检测是否为可行走区域；
- occupied ：已占用位置列表（如其他角色）；
- max_attempts ：最大尝试次数，防止无限循环。

该函数具备容错机制，即使地图拥挤也能返回合理位置，提升鲁棒性。

5.3 控制台图形化显示方案

尽管缺乏图形界面，但通过巧妙运用 ASCII 字符和控制台操作，仍可实现清晰的视觉反馈。

5.3.1 使用字符符号绘制Cat(‘C’)、Mouse(‘M’)、空地(‘.’)

核心绘制函数如下：

void RenderMap(
    const std::vector<std::vector<char>>& map,
    const Position& catPos,
    const Position& mousePos
) {
    auto buffer = map;  // 创建副本避免污染原数据

    // 更新角色位置
    buffer[catPos.y][catPos.x] = 'C';
    buffer[mousePos.y][mousePos.x] = 'M';

    // 输出地图
    for (const auto& row : buffer) {
        for (char cell : row) {
            std::cout << cell << ' ';
        }
        std::cout << '\n';
    }
}

该函数采用“绘制时注入”的方式，不在原始地图中永久记录角色位置，而是每次渲染时临时覆盖，有利于状态分离。

5.3.2 system(“cls”)跨平台清屏兼容处理

清屏指令在 Windows 中为 cls ，Linux/macOS 中为 clear 。为实现跨平台兼容，可封装如下函数：

#include <cstdlib>

void ClearScreen() {
#ifdef _WIN32
    system("cls");
#else
    system("clear");
#endif
}

或者更高级的做法是使用 ANSI 转义序列：

void ClearWithAnsi() {
    std::cout << "\033[2J\033[H";  // 清屏并归位光标
}

这种方式无需调用外部命令，效率更高，且支持大多数现代终端。

5.4 游戏状态变量的全局管理

5.4.1 游戏是否结束、计时器、捕获次数统计

建议将所有全局状态集中管理：

struct GameState {
    bool gameRunning = true;
    int catchCount = 0;
    int gameTimeSec = 0;
    static GameState& GetInstance() {
        static GameState instance;
        return instance;
    }
private:
    GameState() = default;  // 私有构造，单例模式
};

通过单例模式确保全局唯一访问点，避免多处修改造成状态混乱。

5.4.2 单例模式在状态管理中的尝试应用

使用 GetInstance() 获取引用后，可在任意模块中读写状态：

auto& state = GameState::GetInstance();
state.catchCount++;

该设计便于后期集成事件系统或UI更新机制，是中小型项目的理想选择。

6. 游戏主循环与用户交互控制流程

游戏开发中， 主循环（Main Loop） 是整个程序运行的核心骨架。它决定了游戏如何响应玩家输入、更新角色状态、渲染画面以及维持稳定的帧率。在“猫抓老鼠”这类基于控制台的简单游戏中，主循环的设计虽然不涉及复杂的图形引擎或事件系统，但其结构依然需要具备清晰的逻辑分层和良好的可扩展性，以支持后续功能的迭代与优化。

本章将深入剖析主循环的整体架构设计，并围绕用户输入处理、游戏逻辑更新与屏幕刷新三大核心模块展开详细实现。通过合理的代码组织与性能调优策略，构建一个稳定、流畅且具有实时反馈机制的游戏运行环境。

6.1 主循环框架设计（while(running)）

主循环的本质是一个持续执行的 while 循环，只要游戏未结束（即 running == true ），该循环就会不断重复地执行三个关键阶段： 输入处理 → 状态更新 → 画面渲染 。这种“输入-更新-渲染”三段式结构是现代游戏架构的基础模型，广泛应用于从独立小游戏到大型3D引擎的所有类型项目中。

### 6.1.1 每帧执行顺序：输入→更新→渲染

在每一帧中，主循环必须严格按照以下顺序执行：

  1. 输入采集（Input Handling） ：检测键盘、鼠标或其他设备的输入信号。
  2. 逻辑更新（Update Logic） ：根据输入信息更新游戏角色的位置、状态等属性。
  3. 画面重绘（Render Frame） ：将最新的游戏状态输出到屏幕上。

这三步构成了一次完整的“帧周期”。若顺序错乱，例如先渲染再更新，则可能导致显示延迟一帧的内容，造成视觉上的卡顿感。

下面是一个典型的主循环伪代码结构：

bool running = true;
while (running) {
    HandleInput();   // 处理用户输入
    UpdateGame();    // 更新游戏逻辑
    RenderFrame();   // 渲染当前帧
    Sleep(100);      // 控制帧率，每秒约10帧
}
代码逻辑逐行分析：
行号 代码 参数说明与逻辑分析
1 bool running = true; 定义一个布尔变量 running 作为游戏运行标志，初始为 true ，表示游戏开始运行。
3 while (running) 主循环入口，只要 running 为真，循环持续执行。当玩家按下退出键或触发胜利条件时，可将其设为 false 来终止游戏。
4 HandleInput(); 调用输入处理函数，用于监听并解析用户的按键操作，如 WASD 控制猫移动。
5 UpdateGame(); 执行所有游戏对象的状态更新，包括猫追击、老鼠逃跑、碰撞检测等逻辑。
6 RenderFrame(); 将当前地图与角色位置绘制到控制台窗口，提供可视化反馈。
7 Sleep(100); 使用 Windows API 的 Sleep() 函数暂停线程 100 毫秒，从而限制帧率为约 10 FPS（Frames Per Second）。

⚠️ 注意： Sleep() 的精度受操作系统调度影响，实际帧率可能略有波动。对于更高精度的定时需求，建议使用 <chrono> 高精度时钟进行差值计算。

使用 Mermaid 流程图展示主循环流程：
graph TD
    A[开始主循环] --> B{running == true?}
    B -- 是 --> C[处理用户输入]
    C --> D[更新游戏逻辑]
    D --> E[渲染当前帧]
    E --> F[调用 Sleep(100ms)]
    F --> B
    B -- 否 --> G[退出游戏]

该流程图清晰表达了主循环的闭环特性：每一次迭代都必须完成输入、更新、渲染三步后才能进入下一次循环，直到游戏被主动关闭。

### 6.1.2 Sleep()函数控制帧率稳定性

为了防止游戏运行过快导致画面闪烁或 CPU 占用过高，必须对主循环施加时间延迟。C++ 标准库中没有跨平台的睡眠函数，但在 Windows 平台上可以使用 <windows.h> 提供的 Sleep(milliseconds) 函数。

#include <windows.h>

// 在主循环中加入延时
Sleep(100); // 延迟100毫秒，目标帧率约为10FPS
参数说明：
  • milliseconds ：指定线程休眠的时间长度，单位为毫秒（ms）。
  • 推荐值范围：
  • 50~100 ms ：适用于回合制或低速动画游戏（10~20 FPS）
  • 16~33 ms ：对应 60~30 FPS，适合实时动作类游戏

然而， Sleep() 存在精度问题。例如，在多任务操作系统中，线程唤醒时间并不精确，可能导致帧间隔不稳定。为此，我们可以引入更精细的时间控制机制：

#include <chrono>
#include <thread>

const int TARGET_FPS = 10;
const auto FRAME_DURATION = std::chrono::milliseconds(1000 / TARGET_FPS);

auto lastTime = std::chrono::steady_clock::now();

while (running) {
    auto currentTime = std::chrono::steady_clock::now();
    auto deltaTime = currentTime - lastTime;

    if (deltaTime >= FRAME_DURATION) {
        HandleInput();
        UpdateGame();
        RenderFrame();
        lastTime = currentTime;
    } else {
        std::this_thread::sleep_for(std::chrono::microseconds(1000));
    }
}
代码逻辑解读：
步骤 功能描述
TARGET_FPS 设定目标帧率为每秒10帧
FRAME_DURATION 计算每帧应持续的时间（100ms）
steady_clock::now() 获取高精度时间戳
deltaTime >= FRAME_DURATION 判断是否已达到下一帧时机
sleep_for(...) 若未到时间，短暂休眠以降低CPU占用

这种方式相比简单的 Sleep() 更加精准，能够有效避免因系统调度误差引起的帧率抖动，特别适用于对时间敏感的游戏逻辑。

6.2 用户输入处理机制

用户输入是人机交互的关键环节。在“猫抓老鼠”游戏中，玩家通常通过键盘控制猫的移动方向。因此，必须建立一套高效、低延迟的输入监听机制，确保操作响应及时准确。

### 6.2.1 键盘输入监听（getch或cin）

传统上，C++ 使用 cin 进行输入读取，但 cin 是阻塞式的，必须等待回车确认，无法满足实时游戏的需求。为此，我们采用非阻塞式输入函数 getch() （定义于 <conio.h> ，仅限 Windows）来实现即时按键捕获。

#include <conio.h>

char GetPlayerInput() {
    if (_kbhit()) {           // 检测是否有按键被按下
        return _getch();      // 获取按键字符，不需回车
    }
    return 0;                 // 返回0表示无输入
}
参数与行为说明：
函数 作用
_kbhit() 检查键盘缓冲区是否有待处理的按键事件，返回非零值表示有输入
_getch() 直接从键盘读取一个字符，不显示在屏幕上（无回显），常用于快捷指令

🌐 跨平台替代方案：Linux 下可使用 ncurses 库或文件描述符 read(STDIN_FILENO, ...) 实现类似功能；也可封装成抽象接口统一管理。

示例：主循环中集成输入处理
void HandleInput() {
    char input = GetPlayerInput();
    switch (input) {
        case 'W':
        case 'w':
            playerCat.MoveUp(); break;
        case 'S':
        case 's':
            playerCat.MoveDown(); break;
        case 'A':
        case 'a':
            playerCat.MoveLeft(); break;
        case 'D':
        case 'd':
            playerCat.MoveRight(); break;
        case 'Q':
        case 'q':
            running = false; break; // 退出游戏
        default:
            break;
    }
}

此段代码展示了如何将原始按键映射为具体的行为指令，体现了“输入解耦”的设计理念——即输入处理模块不应直接修改游戏状态，而是发出命令由其他模块执行。

### 6.2.2 玩家操控Cat移动（WASD或方向键）

为了让玩家能直观地控制猫的移动，我们采用 WASD 键分别对应上下左右方向。此外，也可以支持方向键（↑↓←→），但需注意其发送的是两个字节序列（前导字节 0xE0 + 方向码）。

char GetPlayerInput() {
    if (_kbhit()) {
        int key = _getch();
        if (key == 0 || key == 224) { // 特殊键前缀
            key = _getch(); // 获取第二个字节
            switch (key) {
                case 72: return 'K'; // 上箭头
                case 80: return 'J'; // 下箭头
                case 75: return 'H'; // 左箭头
                case 77: return 'L'; // 右箭头
            }
        } else {
            return static_cast<char>(key);
        }
    }
    return 0;
}
输入映射表（WASD 与方向键统一处理）：
按键 映射动作 对应方法
W / ↑ 向上移动 MoveUp()
S / ↓ 向下移动 MoveDown()
A / ← 向左移动 MoveLeft()
D / → 向右移动 MoveRight()
Q / Esc 退出游戏 running = false

通过统一的输入映射层，未来可轻松扩展支持手柄、配置文件自定义键位等功能。

6.3 游戏逻辑更新模块

游戏主循环的核心在于每帧对游戏世界的状态进行演化。这一过程由“逻辑更新”模块完成，主要包括角色移动、AI决策、状态判定等内容。

### 6.3.1 Cat根据玩家指令或AI策略移动

在当前版本中，猫的角色既可以由玩家手动控制，也可切换为自动追踪模式。以下是两种模式的实现方式对比：

手动控制模式（Player Mode）
class Cat {
public:
    void Move(char direction) {
        switch (direction) {
            case 'W': y--; break;
            case 'S': y++; break;
            case 'A': x--; break;
            case 'D': x++; break;
        }
        ClampPosition(); // 限制在地图范围内
    }
private:
    int x, y;
    void ClampPosition() {
        x = std::max(0, std::min(x, MAP_WIDTH - 1));
        y = std::max(0, std::min(y, MAP_HEIGHT - 1));
    }
};
自动追踪模式（AI Mode）——最短路径逼近算法
void AutoMoveTowards(const Mouse& mouse) {
    int dx = mouse.GetX() - x;
    int dy = mouse.GetY() - y;

    if (abs(dx) > abs(dy)) {
        x += (dx > 0) ? 1 : -1;
    } else {
        y += (dy > 0) ? 1 : -1;
    }
    ClampPosition();
}

✅ 优点：算法简单高效，适合小规模网格场景
❌ 缺点：无法绕过障碍物，易陷入局部震荡

可通过引入 A* 或 Dijkstra 算法进一步提升寻路智能度。

### 6.3.2 Mouse随机移动算法的周期性触发

老鼠采用随机漫步策略增加游戏不确定性。为了避免频繁移动带来的混乱，设置一个计数器控制移动频率。

int moveCounter = 0;
const int MOVE_INTERVAL = 3; // 每3帧移动一次

void UpdateMouse(Mouse& mouse) {
    moveCounter++;
    if (moveCounter >= MOVE_INTERVAL) {
        mouse.RandomMove(MAP_WIDTH, MAP_HEIGHT);
        moveCounter = 0;
    }
}
RandomMove 实现：
void Mouse::RandomMove(int width, int height) {
    int dir = rand() % 4;
    switch (dir) {
        case 0: y--; break; // 上
        case 1: y++; break; // 下
        case 2: x--; break; // 左
        case 3: x++; break; // 右
    }
    x = (x + width) % width; // 边界循环
    y = (y + height) % height;
}

🔁 边界处理采用模运算实现“穿墙”效果，增强趣味性。

6.4 屏幕刷新与视觉反馈优化

良好的视觉反馈是提升用户体验的重要因素。每次逻辑更新后，必须立即刷新屏幕以反映最新状态。

### 6.4.1 实时重绘地图与角色位置

使用二维字符数组模拟地图，并在每次渲染时重新绘制：

void RenderFrame(const Cat& cat, const Mouse& mouse) {
    char map[20][20] = {};

    // 初始化地图为空地
    for (int i = 0; i < 20; ++i)
        for (int j = 0; j < 20; ++j)
            map[i][j] = '.';

    // 放置角色
    map[cat.GetY()][cat.GetX()] = 'C';
    map[mouse.GetY()][mouse.GetX()] = 'M';

    // 清屏并输出
    system("cls");
    for (int i = 0; i < 20; ++i) {
        for (int j = 0; j < 20; ++j)
            std::cout << map[i][j];
        std::cout << '\n';
    }
}
性能优化建议：
方法 描述
局部重绘 仅更新变动区域而非全屏刷新
双缓冲技术 使用后台缓冲区绘制，减少闪烁
字符着色 利用 SetConsoleTextAttribute 添加颜色

### 6.4.2 添加游戏信息提示（得分、剩余时间）

在地图下方添加状态栏，提升信息透明度：

std::cout << "\n--- GAME INFO ---\n";
std::cout << "Score: " << score << " | ";
std::cout << "Time Left: " << remainingTime << "s\n";
std::cout << "Controls: WASD or Arrow Keys to move, Q to quit\n";

最终呈现效果如下：

......M.............
..........C.........
--- GAME INFO ---
Score: 3 | Time Left: 60s
Controls: WASD or Arrow Keys to move, Q to quit

总结表格：主循环各组件职责划分

模块 职责 使用技术
主循环框架 控制程序生命周期 while(running), Sleep(), chrono
输入处理 捕获并解析用户输入 _kbhit(), _getch()
逻辑更新 更新角色状态与规则判断 Move(), RandomMove(), AI算法
渲染系统 输出可视化结果 system(“cls”), 字符绘图
帧率控制 维持稳定刷新速率 Sleep(), std::this_thread::sleep_for()

通过以上设计，我们构建了一个结构清晰、响应灵敏、易于维护的游戏主循环体系，为后续加入音效、存档、网络联机等功能打下了坚实基础。

7. 碰撞检测与游戏状态持久化机制

7.1 基于坐标的碰撞检测算法实现

在“猫抓老鼠”游戏中，最核心的胜负判定机制依赖于 碰撞检测 。由于游戏采用离散的二维网格地图（如 20x20 的字符阵列），角色位置以整数坐标表示，因此碰撞判断可简化为两个游戏角色是否处于同一坐标点。

7.1.1 判断Cat与Mouse是否处于同一格子

实现原理非常直观：当 Cat 和 Mouse 的 (x, y) 坐标完全相等时，即视为发生碰撞。该逻辑通常在主循环的更新阶段执行：

// 示例：碰撞检测函数
bool CheckCollision(const Cat& cat, const Mouse& mouse) {
    return (cat.GetX() == mouse.GetX()) && (cat.GetY() == mouse.GetY());
}

在游戏主循环中调用此函数，并根据返回值更新游戏状态：

if (CheckCollision(cat, mouse)) {
    std::cout << "\n🎉 老鼠被抓住了！游戏结束！\n";
    running = false;
    gameStats.captureCount++;  // 捕获次数统计
}

为了提升可扩展性，我们可以将此类检测泛化为模板函数或集成进基类 GameObject 的虚方法中，便于未来支持多种对象类型之间的交互检测。

此外，在多鼠或多猫场景下，需遍历所有 Mouse 对象进行逐一比对：

for (const auto& mouse : mice) {
    if (CheckCollision(cat, *mouse)) {
        HandleCatMouseCollision(*mouse);  // 触发捕获逻辑
        break;
    }
}

这种基于坐标的精确匹配方式计算开销小、易于调试，适合本类简单回合制或帧步进式控制台游戏。

检测方式 适用场景 时间复杂度 精确度
坐标相等判断 网格化地图，角色占单格 O(1) 单体 / O(n) 多对象 高
距离阈值法（欧氏距离 < r） 连续空间，圆形判定范围 O(1) 中
边界框重叠（AABB） 图形化矩形精灵 O(1) 中

注：本项目使用第一种方式，因其符合离散网格模型且无性能瓶颈。

7.2 异常处理机制保障程序健壮性

C++ 提供了强大的异常处理机制 try-catch ，用于应对运行时错误，例如数组越界访问、空指针解引用或非法用户输入等。

7.2.1 try-catch捕获越界访问与非法输入

在移动角色时，若未正确校验新坐标是否超出地图边界，可能导致非法内存访问。为此，我们可在关键操作处加入异常防护：

void MoveTo(int newX, int newY, int mapWidth, int mapHeight) {
    if (newX < 0 || newX >= mapWidth || newY < 0 || newY >= mapHeight) {
        throw GameException("移动超出地图边界！");
    }
    x = newX;
    y = newY;
}

主循环中通过 try-catch 捕获并安全恢复：

try {
    playerCat.Move(inputDirection, gameMap);
} catch (const GameException& e) {
    std::cerr << "⚠️  游戏异常：" << e.what() << std::endl;
    std::cout << "按任意键继续...\n";
    _getch();  // 暂停提示，避免崩溃退出
} catch (const std::exception& e) {
    std::cerr << "标准异常：" << e.what() << std::endl;
    running = false;
}

7.2.2 自定义异常类GameException设计

继承自 std::runtime_error 可增强语义清晰度和调试能力：

#include <stdexcept>
#include <string>

class GameException : public std::runtime_error {
public:
    explicit GameException(const std::string& message)
        : std::runtime_error(message.c_str()) {}
};

这样可以在抛出时携带上下文信息，如 "无法加载地图文件: level1.txt" 或 "玩家输入无效指令 'Z'" ，极大提升后期维护效率。

7.3 文件操作实现游戏进度保存与加载

为了让玩家能够中断后继续游戏，必须引入 持久化存储机制 ，利用 C++ 标准库中的 <fstream> 实现数据读写。

7.3.1 使用fstream写入当前角色坐标与分数

保存功能示例代码如下：

void SaveGame(const Cat& cat, const Mouse& mouse, int score) {
    std::ofstream outFile("save.txt");
    if (outFile.is_open()) {
        outFile << cat.GetX() << "\n"
                << cat.GetY() << "\n"
                << mouse.GetX() << "\n"
                << mouse.GetY() << "\n"
                << score << "\n";
        outFile.close();
        std::cout << "💾 游戏已保存至 save.txt\n";
    } else {
        throw GameException("无法打开保存文件！");
    }
}

文件内容格式示例：

10
5
3
8
7

每行依次代表：Cat.x, Cat.y, Mouse.x, Mouse.y, score

7.3.2 重启后读取上次游戏状态（save.txt/load功能）

加载函数需处理文件不存在或数据损坏的情况：

bool LoadGame(Cat& cat, Mouse& mouse, int& score) {
    std::ifstream inFile("save.txt");
    if (!inFile.is_open()) return false;

    try {
        int cx, cy, mx, my;
        if (inFile >> cx >> cy >> mx >> my >> score) {
            cat.SetPosition(cx, cy);
            mouse.SetPosition(mx, my);
            std::cout << "✅ 成功加载存档：得分=" << score << std::endl;
            inFile.close();
            return true;
        } else {
            throw GameException("存档文件数据不完整");
        }
    } catch (...) {
        inFile.close();
        throw;
    }
}

配合主菜单提供选项：

std::cout << "选择模式: (N)ew Game 或 (L)oad Game? ";
char choice;
std::cin >> choice;
if (choice == 'L' || choice == 'l') {
    if (!LoadGame(cat, mouse, score)) {
        std::cout << "❌ 无可用存档，启动新游戏。\n";
        InitNewGame(cat, mouse, score);
    }
} else {
    InitNewGame(cat, mouse, score);
}

7.4 C++游戏开发全流程总结与拓展展望

7.4.1 从需求分析到编码测试的完整开发路径

整个开发流程遵循典型的软件工程生命周期：

graph TD
    A[需求分析] --> B[架构设计]
    B --> C[类建模 UML]
    C --> D[C++ 编码实现]
    D --> E[单元测试与调试]
    E --> F[功能集成]
    F --> G[用户测试反馈]
    G --> H[优化重构]
    H --> I[发布与维护]

各阶段输出物包括：
- 类图文档（UML）
- .h/.cpp 分离实现
- 控制台可视化界面
- 支持保存/加载的持久层
- 异常安全机制

7.4.2 向图形界面（SFML/SDL）迁移的技术路线建议

虽然当前版本基于控制台，但代码结构已具备良好抽象基础，便于向图形库迁移：

当前模块 替代方案 技术要点
字符绘制 SFML Texture/Sprite 加载 PNG 图片资源
Sleep()帧控 sf::Clock / FPS限制器 更精准的时间管理
键盘输入 sf::Event handling 支持鼠标、手柄等设备
地图渲染 sf::RenderWindow 双缓冲防闪烁
状态管理 State Pattern + Scene Manager 菜单、关卡切换

迁移步骤建议：
1. 引入 SFML 库（通过 vcpkg 或手动配置）
2. 将 Draw() 方法从 cout 改为 window.draw(sprite)
3. 使用 sf::Texture 加载角色贴图
4. 重构主循环为事件驱动模式
5. 添加音效与背景音乐（ sf::SoundBuffer , sf::Music ）

此举不仅能显著提升用户体验，也为后续网络对战、AI训练等高级功能打下基础。

本文还有配套的精品资源，点击获取 menu-r.4af5f7ec.gif

简介：《猫抓老鼠——C++实现详解》是一篇面向编程学习者的实践教程，通过使用C++语言模拟真实生活场景中的追捕游戏，帮助读者掌握C++基础语法、面向对象编程思想及游戏逻辑设计方法。文章详细讲解了类的设计与封装、继承与多态的应用、游戏主循环机制、碰撞检测逻辑、用户输入处理以及异常和文件操作等核心技术。本项目不仅强化编程基础，还提升逻辑思维与实际开发能力，是C++初学者进行综合项目实践的理想选择。


本文还有配套的精品资源，点击获取
menu-r.4af5f7ec.gif

Logo
AI Agent技术社区

Agent 垂直技术社区，欢迎活跃、内容共建。

更多推荐

零成本在终端里搭建 AI 编程智能体（Open Interpreter + 智谱免费模型）

作为嵌入式开发者，我一直在寻找一种能的 AI 工具。Claude Code 虽然强大，但需要付费 API 且国内网络不稳定；GitHub Copilot 依赖 IDE，不够灵活。后来我发现了——一个开源的终端 AI Agent，支持多种大模型后端。配合智谱 AI 的免费模型，我实现了，能读写文件、执行 Shell 命令、管理 QEMU 虚拟机，极大提升了内核和驱动学习效率。这篇文章记录完整的搭建过

avatar AI Agent技术社区

如何成为一名 AI Agent 工程师：从入门到精通的完整指南

AI Agent 工程师是专注于设计、开发和部署智能代理（Intelligent Agent）的专业技术人员。AI Agent 是一种能够感知环境、自主决策并执行行动以实现特定目标的软件实体。与传统的 AI 模型（如分类器、生成器）不同，AI Agent 强调在动态环境中的持续交互、规划与学习能力。自动化工作流：构建能够处理复杂、多步骤任务的自动化助手，如数据分析、报告生成、客户服务等。游戏与模拟

avatar AI Agent技术社区
cover

AI Agent 多角色协作总是重复问需求？用单一事实源串起文档、代码和测试

avatar AI Agent技术社区