本文还有配套的精品资源，点击获取

简介：本资源包将引导你了解如何使用C++编程语言开发一个五子棋游戏。五子棋是一种两人对弈的策略型棋类游戏，目标是在棋盘上形成连续的五个棋子。学习本课程，你将掌握C++编程基础，包括面向对象编程（OOP）概念，以及如何设计棋盘、处理棋子放置、检查胜负、AI设计、用户交互、游戏流程控制、错误处理、代码组织以及进行调试与测试。本资源包还可能包含五子棋的测试资源，如棋盘图片、示例棋局等。如果你对图形界面或网络对战功能感兴趣，本课程也将提供进一步学习的方向。

1. C++基础语法和面向对象编程

1.1 C++概述

C++是一种静态类型、编译式、通用的编程语言，它支持过程化、面向对象以及泛型编程。作为C语言的超集，C++在继承C语言高效、灵活等优点的同时，又增加了面向对象编程的特性。

1.2 C++基础语法

学习C++的基础语法是掌握编程的关键。这包括数据类型、变量、常量、运算符、控制结构（if, switch, while, for等）以及函数的定义与使用。

#include <iostream>
using namespace std;

int main() {
    // 输出Hello World到控制台
    cout << "Hello, World!" << endl;
    return 0;
}

1.3 面向对象编程基础

面向对象编程（OOP）是一种编程范式，利用“对象”来设计软件。对象可以包含数据（属性）和代码（方法）。C++支持OOP的三大核心概念：封装、继承和多态。

封装

封装是将数据（属性）和代码（方法）捆绑在一起，并对外隐藏实现细节，只暴露接口。这通过类（class）来实现。

class Rectangle {
private:
    int width, height;
public:
    void setValues(int w, int h) {
        width = w;
        height = h;
    }
};

继承

继承允许创建一个类的继承体系。子类继承父类的属性和方法，并可以添加或修改它们。

class Vehicle {
public:
    void run() { /* ... */ }
};

class Car : public Vehicle {
    // Car类继承了Vehicle类
};

多态

多态是相同的操作作用于不同的对象，可以有不同的解释和不同的执行结果。在C++中，多态通常通过虚函数实现。

class Base {
public:
    virtual void print() { /* ... */ } // 虚函数
};

class Derived : public Base {
    void print() override { /* ... */ } // 重写基类的虚函数
};

掌握C++的基础语法和面向对象编程对于开发复杂的程序至关重要，它为后续章节中设计棋盘、实现棋子放置以及AI算法提供了坚实的基础。

2. 棋盘设计与状态更新

2.1 棋盘数据结构设计

2.1.1 棋盘矩阵的构建

在实现棋盘的基础设计时，首先需要构建一个表示棋盘的数据结构。棋盘可以被抽象成一个二维矩阵，其中每个元素代表棋盘上的一个位置。为了容纳不同类型的棋子，我们使用一个整型数组来表示棋盘，其中不同的整数值可以代表不同的棋子类型。

假设我们的棋盘是九宫格，每方各放置一种类型的棋子（例如，“X”和“O”），我们可以定义如下数据结构：

#define BOARD_SIZE 3 // 九宫格大小定义为3x3

int board[BOARD_SIZE][BOARD_SIZE] = {0}; // 初始化棋盘数组，0表示空位置

为了更好地表示棋盘，我们还可以为每个整数值定义一个枚举类型，以清晰表示不同的棋子：

enum class Piece {
    EMPTY = 0, // 空位
    PLAYER_X, // 玩家X的棋子
    PLAYER_O  // 玩家O的棋子
};

2.1.2 棋盘状态的表示方法

棋盘状态包括了棋盘上所有棋子的分布情况，是游戏进行时最重要的数据结构。采用上文中的二维数组 board 来表示当前棋盘的状态。每个 board[i][j] 元素对应棋盘上的第 i 行第 j 列的棋子类型。

对于九宫格而言，一个初始的棋盘状态可以表示为：

0 0 0
0 0 0
0 0 0

其中 0 表示空位。当玩家开始下棋时，比如玩家X在左上角第一个位置下了一子，则棋盘状态更新为：

1 0 0
0 0 0
0 0 0

在这里，我们用 1 来表示玩家X的棋子，同时定义 2 来表示玩家O的棋子。通过数组索引和枚举值的对应，我们可以清晰地描述出当前棋盘上每个位置的棋子状态。

2.2 棋盘状态更新机制

2.2.1 棋盘状态更新规则

棋盘状态更新规则通常由游戏的规则决定。以井字棋（Tic-Tac-Toe）为例，每轮玩家选择一个空位置放置自己的棋子，更新规则如下：

1. 玩家轮流在空位置上放置自己的棋子。
2. 放置棋子后，检查是否有玩家赢得了游戏（即连续三个相同的棋子出现在一条直线上）。
3. 如果有玩家获胜，游戏结束。
4. 如果所有位置都被占用而没有玩家获胜，则为平局。

2.2.2 棋盘状态更新算法实现

以下是棋盘状态更新的算法实现，考虑了用户输入处理和合法性验证。

bool placePiece(int row, int col, Piece player) {
    if (row < 0 || col < 0 || row >= BOARD_SIZE || col >= BOARD_SIZE) {
        // 输入的行列超出了棋盘范围
        return false;
    }
    if (board[row][col] != 0) {
        // 该位置已有棋子
        return false;
    }
    board[row][col] = player; // 更新棋盘状态
    return true;
}

在上面的代码中， placePiece 函数负责在棋盘上放置一个棋子。如果输入的位置合法（即行、列索引在棋盘范围内且该位置为空），则将对应玩家的棋子放置到指定位置，并返回 true 表示成功。如果位置不合法（例如位置已被占用或者超出棋盘范围），则返回 false 。

2.2.2 棋盘状态更新算法实现（续）

为了更好地展示代码块和代码逻辑分析，我们可以详细地解释这段代码的执行流程以及参数说明：

• 函数 placePiece 有三个参数： row 和 col 分别代表要放置棋子的位置的行和列， player 是一个枚举类型，代表是哪位玩家的回合。

• 首先检查输入的行列索引是否合法，如果超出了棋盘大小的范围，函数返回 false ，表明无法放置棋子。

• 然后检查该位置是否已经有棋子（即 board[row][col] 是否等于 0 ）。如果已经有棋子，同样返回 false 。

• 如果以上两个条件都不成立，说明这个位置可以放置棋子，于是将 board[row][col] 更新为当前玩家的棋子类型，并返回 true 表示放置成功。

这段代码展示了如何在棋盘上正确地放置棋子，并确保游戏状态的合法性。代码简洁，逻辑清晰，是游戏开发中常见的一个算法实现。

以上内容涵盖了棋盘的设计以及如何更新棋盘状态的基本机制。下一章节将详细讨论棋子的放置逻辑以及如何展示棋盘的更新效果。

3. 棋子放置实现

3.1 棋子放置逻辑

3.1.1 用户输入处理

棋子放置是游戏的核心交互环节之一。用户输入的处理需要准确无误地捕捉玩家的意图，并将其转化为游戏动作。这通常涉及以下几个步骤：

• 监听玩家操作 ：实时监听玩家的鼠标点击或触摸屏幕的坐标，这些坐标被转换为棋盘上的位置。
• 坐标转换 ：将屏幕坐标转换为棋盘数组中的索引，以便于后续逻辑的处理。
• 放置逻辑判断 ：根据当前游戏状态，判断玩家的放置操作是否合法。例如，在已放置棋子的位置无法再放置新的棋子。
• 放置棋子 ：一旦确定玩家的意图和操作的合法性，就可以在相应位置放置对应的棋子。

下面是一个简单的C++代码示例，展示了如何根据用户输入在棋盘上放置棋子：

void placePiece(int x, int y, char piece) {
    if (x >= 0 && x < BOARD_SIZE && y >= 0 && y < BOARD_SIZE) {
        if (board[x][y] == EMPTY) {
            board[x][y] = piece;
        } else {
            // 输出错误提示，玩家尝试在已有棋子的位置放置
            std::cout << "Invalid move. Position (" << x << ", " << y << ") is already occupied." << std::endl;
        }
    } else {
        // 输出错误提示，玩家尝试放置超出棋盘范围的位置
        std::cout << "Invalid move. Position (" << x << ", " << y << ") is out of bounds." << std::endl;
    }
}

代码分析：

• placePiece 函数接收玩家意图的坐标(x, y)和要放置的棋子类型(piece)。
• 检查坐标是否在棋盘范围内，若不在输出错误信息。
• 检查指定位置是否为空，若空则放置棋子，否则输出错误信息。
• 函数直接修改全局变量 board 以反映棋盘的新状态。

3.1.2 棋子放置合法性验证

确保玩家放置棋子的动作符合规则是游戏逻辑的一个重要部分。以下是一些基本的合法性验证：

• 检查落子位置 ：棋子不能放置在已经被占据的位置上。
• 检查胜负条件 ：在某些游戏规则中，新放置的棋子可能会立即导致游戏结束，如井字棋中的连线。
• 特殊规则 ：某些游戏可能有额外的放置规则，比如禁手等，这些都需要在合法性验证中加以考虑。

下面是一个C++函数示例，用于验证玩家放置棋子的合法性：

bool isValidMove(int x, int y, char playerPiece) {
    if (x < 0 || x >= BOARD_SIZE || y < 0 || y >= BOARD_SIZE) {
        return false; // 落子位置超出棋盘范围
    }
    if (board[x][y] != EMPTY) {
        return false; // 落子位置已被占据
    }
    // 这里可以添加更多的验证，比如检查是否形成连线等

    return true;
}

代码分析：

• isValidMove 函数用于确认给定的落子位置和玩家棋子是否合法。
• 函数检查落子位置是否在棋盘范围内，并且该位置是否为空。
• 根据游戏规则，函数可以进一步扩展以包含其他类型的合法性检查，比如形成连线等。

3.2 棋子放置效果展示

3.2.1 棋盘界面更新

棋子放置后，需要实时更新棋盘界面以反映出最新的游戏状态。这可以通过以下步骤实现：

• 清除屏幕 ：在某些图形界面库中，这可能意味着清除整个屏幕。
• 重新绘制棋盘 ：重新绘制棋盘上的每个格子，显示其中的棋子。
• 动画效果 ：可选地添加动画效果，如棋子的淡入淡出，以提升用户体验。
• 高亮合法落子位置 ：如果游戏支持，可以高亮显示玩家当前可以合法落子的位置。

下面是一个伪代码示例，展示棋盘界面更新的过程：

function updateBoardUI() {
    clearScreen();
    for each cell in board {
        drawCell(cell);
    }
    highlightLegalMoves();
}

3.2.2 视觉效果优化

为了提升游戏体验，棋盘界面的视觉效果也需要精心设计。这包括：

• 颜色选择 ：使用适合的背景色和棋子颜色，确保清晰的对比度和舒适的视觉体验。
• 动画流畅性 ：确保棋子放置和界面更新时的动画流畅，无明显的延迟或卡顿。
• 界面布局 ：合理的界面布局能够更好地引导玩家的视线，突出重点信息，如当前轮到谁走棋。
• 字体与符号 ：使用恰当的字体和棋子符号，增加界面美观度和辨识度。

以下是一个简单的mermaid流程图，展示了棋盘界面更新的流程：

graph LR
A[清除屏幕] --> B[重新绘制棋盘]
B --> C[绘制棋子]
C --> D[高亮合法落子位置]
D --> E[界面更新完成]

接下来的章节将会进一步深入介绍胜负检查算法的设计与优化，以及AI设计与实现，最终将带领读者深入到用户交互界面设计，为玩家提供更加丰富和人性化的体验。

4. 胜负检查算法

4.1 胜负判断规则

4.1.1 连续棋子数判断

在讨论连续棋子数判断之前，首先需要明确游戏规则对于“胜利”的定义。以经典的井字棋(Tic-Tac-Toe)为例，当一名玩家在水平、垂直或对角线方向上连续放置了三个自己的棋子时，该玩家获胜。为了实现这一规则，我们可以用一个二维数组来表示棋盘状态，并根据数组中的数据来进行连续棋子数的判断。

下面是一个简单的二维数组表示棋盘的示例：

char board[3][3] = {
    {'X', 'O', 'X'},
    {'O', 'O', 'X'},
    {'X', 'X', 'O'}
};

在这个数组中，’X’ 和 ‘O’ 分别代表两位玩家的棋子。在检查是否有人获胜时，我们可以通过遍历这个数组，对每一行、每一列以及两条对角线进行检查，查看是否有三个相同的棋子连在一起。下面是一个用于检查水平方向获胜条件的函数示例：

bool checkHorizontalWin(char board[3][3]) {
    for (int i = 0; i < 3; ++i) {
        if (board[i][0] == board[i][1] && board[i][1] == board[i][2] && board[i][0] != ' ') {
            return true;
        }
    }
    return false;
}

以上函数仅检查水平方向的获胜情况。同样的逻辑可以被应用于检查垂直和对角线方向。

4.1.2 胜负判断流程

一旦游戏达到特定的棋子数或者棋盘被填满，就需要进行胜负判断。以下是胜负判断的典型流程：

1. 检查是否有空位 ：如果棋盘上还有空位，游戏继续。
2. 遍历棋盘 ：对每个格子进行检查，确保没有任何玩家获胜。
3. 判断胜利条件 ：基于上述的判断规则，检查是否有玩家的棋子达到了连续三个的标准。
4. 判断平局 ：如果没有玩家获胜且棋盘已满，则判定为平局。
5. 输出结果 ：根据第3和第4步的结果，输出获胜玩家的标记或“平局”。

在实现这个流程时，需要考虑代码的效率和可读性。为了提高效率，可以将检查水平、垂直和对角线的函数进行优化，以减少重复代码和提高代码的复用度。

4.2 胜负检查算法优化

4.2.1 算法效率提升策略

在胜负检查算法中，效率的提升主要体现在减少不必要的计算。以下是一些优化策略：

• 避免重复检查 ：在多次检查过程中，可以将中间结果保存下来，避免重复计算。
• 提前退出 ：如果在检查过程中已经发现了获胜的条件，那么可以立即退出检查，避免后续无意义的计算。
• 按需检查 ：只在必要时检查特定的获胜条件，例如，当某玩家放置最后一个棋子时，只检查与该棋子相关的获胜条件。

以下是一个优化后的胜负检查算法示例：

bool checkWin(char board[3][3]) {
    // 检查水平、垂直和对角线获胜条件
    if (checkHorizontalWin(board) || checkVerticalWin(board) || checkDiagonalWin(board)) {
        return true;
    }
    return false;
}

在这个示例中， checkHorizontalWin 、 checkVerticalWin 和 checkDiagonalWin 是预先定义的函数，用于检查各自的获胜条件。这样的结构使得代码更加模块化和易于维护。

4.2.2 胜负结果反馈机制

胜负结果反馈机制不仅包括向玩家显示胜负结果，还应包括游戏状态的记录和处理。以下是实现这个机制的几个关键步骤：

• 记录游戏状态 ：在胜负判断时记录获胜玩家或平局的信息，并将其保存到日志中。
• 玩家反馈 ：使用图形界面或文本输出来告知玩家胜负情况。
• 重置或退出游戏 ：给予玩家选择重置游戏或退出的选项。

在图形界面的应用中，胜负结果反馈可以通过弹出消息框的方式展现给玩家，例如：

if (checkWin(board)) {
    MessageBox(NULL, "X wins!", "Game Over", MB_OK);
} else if (isBoardFull(board)) {
    MessageBox(NULL, "Draw!", "Game Over", MB_OK);
}

在文本控制台游戏中，可以通过打印信息来告知玩家：

if (checkWin(board)) {
    cout << "X wins!" << endl;
} else if (isBoardFull(board)) {
    cout << "Draw!" << endl;
}

通过以上章节的介绍，我们深入了解了胜负检查算法的设计和优化策略。接下来的章节将介绍如何利用这些概念来设计和实现人工智能算法，从而创建出更加具有挑战性和娱乐性的游戏。

5. AI设计与实现

在现代棋类游戏的开发中，AI设计是一个不可或缺的部分，特别是在需要人机对战功能的游戏中。AI不仅能够提升游戏的可玩性，还可以在一定程度上模拟真实的游戏对手，从而提高玩家的游戏体验。本章节将深入探讨AI的设计与实现过程。

5.1 AI算法选择与应用

5.1.1 常用AI算法概述

AI算法的选择是实现智能对手的关键。在棋类游戏中，常见的AI算法包括极小化极大算法（Minimax）、α-β剪枝、蒙特卡洛树搜索（MCTS）以及深度学习方法等。

• 极小化极大算法（Minimax） ：一种经典的决策规则算法，它通过构建游戏树来模拟所有可能的游戏进程，并假定对方总是会做出最优决策，从而使自己处于最差情况下的最好位置。

• α-β剪枝 ：是Minimax算法的优化版本，通过减少需要评估的节点数来提高算法的效率。

• 蒙特卡洛树搜索（MCTS） ：一种随机模拟算法，它通过随机采样来构建游戏树，并依赖于统计来估计节点的价值。

• 深度学习方法 ：例如使用卷积神经网络（CNN）和强化学习（尤其是AlphaZero中的蒙特卡洛树搜索与深度学习相结合的方法）。

每种算法都有其优势和局限性，在实际应用中需要根据游戏的特性进行选择。

5.1.2 算法优缺点比较及选择

在选择AI算法时，需要考虑以下几个因素：算法的效率、AI的水平、资源消耗以及开发难度等。

以围棋游戏为例，AlphaZero使用深度学习和MCTS，超越了传统算法的局限性，并达到了接近职业水平的游戏能力。然而，这种算法需要大量的计算资源进行训练，并且算法复杂度较高。

对于大多数开发者而言，考虑到资源和开发周期的限制，可能会选择α-β剪枝作为游戏AI的核心算法。此算法相对容易实现，且在一定搜索深度下能够提供满意的对局水平。

5.2 AI决策逻辑实现

5.2.1 棋局评估函数设计

棋局评估函数是AI决策逻辑中的核心，它负责评估当前棋局状态的好坏。设计一个好的评估函数通常需要深入了解游戏的规则和策略。

在评估函数中，通常会考虑以下因素：
- 棋子数量 ：控制某个区域或整体棋盘上的棋子数量。
- 棋型 ：如活三、眠四、活四等特殊棋型的价值。
- 棋型组合 ：多个棋型组合起来可能形成的价值。
- 棋盘平衡 ：评价整个棋盘的稳定性。
- 棋型发展潜力 ：考虑棋型未来可能的发展空间。

评估函数的设计需要通过不断的测试和调整，以确保AI的水平能够符合预期。

5.2.2 搜索策略与优化

搜索策略决定了AI如何选择下一步的行动。α-β剪枝算法是一种常用的搜索优化策略，通过剪枝技术避免评估那些在当前搜索深度下不可能是最优的节点，从而降低计算复杂度。

搜索算法实现的关键点如下：

1. 递归搜索函数 ：通过递归实现搜索树的构建和节点的评估。

2. 剪枝条件 ：设置合适的α和β值进行剪枝。

3. 迭代深化 ：逐步增加搜索深度以提高AI的决策质量。

4. 启发式评估 ：结合棋局评估函数，根据当前棋局特点进行启发式评估。

下面是一个简化的α-β剪枝伪代码示例：

function alphaBeta(node, depth, alpha, beta, maximizingPlayer):
    if depth == 0 or node is a terminal node:
        return heuristicEvaluation(node)
    if maximizingPlayer:
        value := -∞
        for each child of node:
            value := max(value, alphaBeta(child, depth - 1, alpha, beta, False))
            alpha := max(alpha, value)
            if beta <= alpha:
                break // β剪枝
        return value
    else:
        value := +∞
        for each child of node:
            value := min(value, alphaBeta(child, depth - 1, alpha, beta, True))
            beta := min(beta, value)
            if beta <= alpha:
                break // α剪枝
        return value

这个伪代码展示了一个基础的α-β剪枝算法的实现逻辑。值得注意的是，实际实现中还需要考虑多线程搜索、缓存机制以及其它优化策略来提升效率。

通过深入研究和分析AI算法在棋类游戏中的应用，开发者能够设计出既智能又高效的AI对手，极大提升游戏的娱乐性和教育价值。随着技术的发展，AI算法在游戏中的应用也将会越来越多样化和深入。

6. 用户交互界面设计

在现代软件开发中，用户交互界面（UI）的设计至关重要，它直接关系到用户的使用体验和产品的受欢迎程度。本章将探讨如何设计一个美观且易用的用户界面，以及如何实现界面功能并优化用户体验。

6.1 界面布局与风格

6.1.1 界面元素设计

在设计界面元素时，需要考虑每个组件的视觉效果和布局位置。对于本棋类游戏，界面应包括以下基本元素：

• 标题栏 ：显示游戏名称和当前状态（例如，当前轮到哪方玩家）。
• 棋盘区域 ：展示游戏的主体部分，即棋盘。棋盘上的每个交叉点均应响应用户的点击事件。
• 信息栏 ：显示当前玩家的信息，如名字、胜率和剩余步数等。
• 控制按钮 ：如“悔棋”、“重新开始”、“游戏帮助”等。
• 状态指示器 ：显示当前游戏进程，如时间、轮次和胜负等信息。

每个元素的风格应与整体设计相协调，考虑到色彩、字体、形状和间距等因素，以确保信息传达清晰并吸引用户。

6.1.2 用户体验优化

用户体验（UX）优化是一个持续的过程，需要从用户的行为习惯和反馈中不断迭代改进。以下是一些提升用户体验的策略：

• 简洁直观的操作流程 ：避免过多复杂的操作，简化用户决策路径。
• 清晰的指引和提示 ：对新用户友好，提供必要的游戏规则介绍和操作说明。
• 优化加载和响应时间 ：确保界面的快速加载和流畅的交互响应。
• 兼容性与可访问性 ：支持多种设备和操作系统，考虑不同用户的需求，如字体大小可调整，高对比度模式等。

6.2 界面功能实现

6.2.1 功能模块划分

为了实现用户界面的模块化管理，我们需要将界面分为几个独立的功能模块。这些模块应包括：

• 游戏管理模块 ：控制游戏的开始、暂停和结束。
• 玩家管理模块 ：处理玩家信息、角色选择和轮次切换。
• 棋盘控制模块 ：响应玩家的点击事件，放置棋子，更新棋盘状态。
• 显示控制模块 ：调整游戏界面的显示内容，如步数、时间等。
• 帮助与设置模块 ：提供游戏帮助和用户设置界面。

每个模块的职责应明确，避免功能重叠或遗漏。

6.2.2 功能实现与交互逻辑

实际实现界面功能时，涉及的编程和交互逻辑是复杂的。例如，实现棋盘控制模块可能需要以下步骤：

1. 棋盘矩阵构建 ：初始化一个二维数组，用于表示棋盘上的每一个点。
2. 响应玩家点击 ：捕捉玩家在棋盘上的点击事件，并转化为在二维数组上的操作。
3. 合法性验证 ：检查玩家的移动是否符合游戏规则。
4. 更新棋盘状态 ：根据玩家的动作更新棋盘矩阵。
5. 界面反馈 ：实时更新界面显示，如棋子的放置、胜者信息等。

以下是一个简单的代码示例，展示了如何使用C++和一个假设的GUI库来处理玩家点击事件：

void onPlayerClick(int x, int y) {
    // 检查坐标合法性
    if (isValidPosition(x, y)) {
        // 在棋盘矩阵上放置棋子
        board[x][y] = currentPlayer;
        // 更新界面显示
        updateDisplay(x, y);
        // 检查胜负
        checkForWin(x, y);
    }
}

bool isValidPosition(int x, int y) {
    // 确保坐标在棋盘范围内且当前位置为空
    return x >= 0 && x < BOARD_SIZE && y >= 0 && y < BOARD_SIZE && board[x][y] == EMPTY;
}

此代码段展示了玩家点击事件的基本处理流程：验证坐标合法性、更新棋盘状态、更新界面显示，并检查游戏是否结束。这个过程中，每个函数都有明确的职责，并且被设计成易于理解和维护的样式。

用户交互界面设计是一个综合性的任务，需要将视觉设计、交互逻辑和用户体验紧密结合起来，才能创造出既美观又易用的产品。通过上述各个方面的探讨，我们可以看到一个复杂系统背后的设计思路和实现策略。

本文还有配套的精品资源，点击获取

简介：本资源包将引导你了解如何使用C++编程语言开发一个五子棋游戏。五子棋是一种两人对弈的策略型棋类游戏，目标是在棋盘上形成连续的五个棋子。学习本课程，你将掌握C++编程基础，包括面向对象编程（OOP）概念，以及如何设计棋盘、处理棋子放置、检查胜负、AI设计、用户交互、游戏流程控制、错误处理、代码组织以及进行调试与测试。本资源包还可能包含五子棋的测试资源，如棋盘图片、示例棋局等。如果你对图形界面或网络对战功能感兴趣，本课程也将提供进一步学习的方向。

本文还有配套的精品资源，点击获取