在第一节中，我们将介绍数组的概念、声明和初始化方法，以及演示数组的基本操作。为了使教学内容更加生动有趣，我们可以通过一些比较强烈的例子来说明数组的应用。

教学内容：

#### 数组的概念和特点：

• 数组是一种线性数据结构，由相同类型的元素组成，这些元素在内存中是连续存储的。
• 数组的长度是固定的，在声明时就确定了，不能动态改变。

#### 声明和初始化数组：

• 示范如何声明数组，并介绍如何初始化数组。
• 例如：int scores[5]; 声明了一个包含5个整数的数组。
  #### 数组的基本操作示例：
• 访问元素：通过索引访问数组中的元素。
• 修改元素：可以直接通过索引修改数组中的元素。
• 遍历数组：使用循环结构遍历数组中的所有元素。

应用例子：

成绩管理系统：

让学生设想一个成绩管理系统，其中需要存储学生的成绩数据。使用数组来存储学生的成绩，每个元素代表一个学生的成绩。
示范如何通过数组实现添加、删除、查找学生成绩的功能。

温度记录器：

想象一个温度记录器，记录每天的气温。使用数组来存储每天的温度数据，每个元素代表一天的温度。
示范如何使用数组计算一周内的平均温度、最高温度和最低温度。

电影票售卖系统：

设想一个电影票售卖系统，记录每天不同电影的售票情况。使用数组来存储每部电影的售票数量，每个元素代表一部电影的售票数量。
示范如何通过数组实现统计每部电影的总票数、最畅销电影等功能。

通过这些应用例子，学生可以更好地理解数组的概念和用途，同时激发他们对学习的兴趣。

成绩管理系统

参考代码

    #include <iostream>
    using namespace std;
    
    int main() {
        const int MAX_STUDENTS = 5;
        int scores[MAX_STUDENTS];
    
        // 添加学生成绩
        for (int i = 0; i < MAX_STUDENTS; ++i) {
            cout << "请输入第 " << i + 1 << " 个学生的成绩: ";
            cin >> scores[i];
        }
    
        // 显示学生成绩
        cout << "学生成绩列表：" << endl;
        for (int i = 0; i < MAX_STUDENTS; ++i) {
            cout << "第 " << i + 1 << " 个学生的成绩为: " << scores[i] << endl;
        }
    
        return 0;
    }

温度记录器

参考代码

    #include <iostream>
    using namespace std;
    
    int main() {
        const int DAYS = 7;
        int temperatures[DAYS];
        int sum = 0;
    
        // 输入每天的温度
        for (int i = 0; i < DAYS; ++i) {
            cout << "请输入第 " << i + 1 << " 天的温度: ";
            cin >> temperatures[i];
            sum += temperatures[i];
        }
    
        // 计算平均温度
        double average = static_cast<double>(sum) / DAYS;
        cout << "一周内的平均温度为: " << average << " 度" << endl;
    
        // 查找最高和最低温度
        int maxTemp = temperatures[0];
        int minTemp = temperatures[0];
        for (int i = 1; i < DAYS; ++i) {
            if (temperatures[i] > maxTemp) {
                maxTemp = temperatures[i];
            }
            if (temperatures[i] < minTemp) {
                minTemp = temperatures[i];
            }
        }
        cout << "最高温度为: " << maxTemp << " 度" << endl;
        cout << "最低温度为: " << minTemp << " 度" << endl;
    
        return 0;
    }

电影票售卖系统

参考代码

    #include <iostream>
    using namespace std;
    
    int main() {
        const int NUM_MOVIES = 3;
        int ticketSales[NUM_MOVIES] = {0};
    
        // 模拟售票过程
        for (int i = 0; i < NUM_MOVIES; ++i) {
            cout << "请输入电影 " << i + 1 << " 的售票数量: ";
            cin >> ticketSales[i];
        }
    
        // 统计总票数和最畅销电影
        int totalSales = 0;
        int bestMovieIndex = 0;
        for (int i = 0; i < NUM_MOVIES; ++i) {
            totalSales += ticketSales[i];
            if (ticketSales[i] > ticketSales[bestMovieIndex]) {
                bestMovieIndex = i;
            }
        }
    
        // 显示统计结果
        cout << "总售票数量为: " << totalSales << endl;
        cout << "最畅销电影是电影 " << bestMovieIndex + 1 << endl;
    
        return 0;
    }

以下是一个简单的教学计划，旨在向初中生介绍基础的数据结构概念，并使用C++语言进行说明和示范。这个计划将包括讲解线性数据结构（数组、链表）和非线性数据结构（栈、队列）。

教学计划

第一节：数组（Array）

• 介绍数组的概念和特点。
• 讲解如何声明和初始化数组。
• 演示数组的基本操作，如访问元素、修改元素和遍历数组。
• 讨论数组的优缺点及应用场景。

第二节：链表（Linked List）

• 介绍链表的概念和基本类型（单链表、双链表）。
• 演示如何定义和操作单链表。
• 讨论链表与数组的区别，以及链表的优势。
• 分析链表的插入、删除和查找操作的时间复杂度。

第三节：栈（Stack）

• 介绍栈的概念和特点。
• 演示如何使用栈实现简单的表达式求值和括号匹配。
• 讨论栈的应用场景，如函数调用栈和浏览器的前进后退功能。

第四节：队列（Queue）

• 介绍队列的概念和特点。
• 演示如何使用队列解决问题，如模拟排队和广度优先搜索（BFS）算法。
• 讨论队列的应用场景，如任务调度和消息传递。

辅助资源和活动

• 提供课堂演示和实践练习，让学生动手实践数据结构的基本操作。
• 组织小组讨论，让学生分享自己对数据结构的理解和应用场景。
• 分发资料和练习题，供学生课后复习和巩固知识。

评估方式

• 课堂参与度：评估学生在课堂上的提问和回答情况。
• 实践练习：评估学生对数据结构基本操作的掌握程度。
• 课后作业：布置相关的编程作业，检验学生对所学内容的理解和应用能力。

结语

通过这个教学计划，学生将能够了解基本的数据结构概念，并通过C++语言实践掌握数组、链表、栈和队列等常用数据结构。同时，他们也将学会如何分析和应用这些数据结构解决实际问题。

题目1

• 描述
  把前n个数字排列在一起，统计一下0～9各出现多少次？ 编写C++程序
• 输入
  整数n
• 输出
  0～9 各出现次数

#include <iostream>
#include <vector>

int main() {
    int n;
    std::cout << "请输入数字n: ";
    std::cin >> n;

    // 创建一个数组来存储0到9各数字的出现次数，初始化为0
    int count[10] = {0};

    // 将前n个数字排列在一起
    for (int i = 1; i <= n; i++) {
        int num = i;
        while (num > 0) {
            // 获取最后一位数字
            int digit = num % 10;
            // 增加相应数字的计数
            count[digit]++;
            // 去掉最后一位数字
            num /= 10;
        }
    }

    // 输出统计结果
    std::cout << "0~9各数字出现的次数为：" << std::endl;
    for (int i = 0; i < 10; i++) {
        std::cout << i << ": " << count[i] << std::endl;
    }

    return 0;
}

题目2

• 描述
  周期串，如果一个字符串可以由某个长度为k的字符串多次重复得到，则称该串以k为周期，输入一个长度不超过80的字符串，输出其最小周期，编写C++程序
• 输入
  长度不超过80的字符串
• 输出
  最小周期，一个整数，或者不存在

#include <iostream>
#include <string>

int findSmallestPeriod(const std::string& input) {
    int n = input.length();
    for (int k = 1; k <= n; k++) {
        if (n % k == 0) {
            bool isPeriod = true;
            for (int i = k; i < n; i++) {
                if (input[i] != input[i % k]) {
                    isPeriod = false;
                    break;
                }
            }
            if (isPeriod) {
                return k;
            }
        }
    }
    return n; // 如果没有找到周期，则返回字符串长度
}

int main() {
    std::string input;
    std::cout << "请输入一个字符串（长度不超过80）: ";
    std::cin >> input;

    int smallestPeriod = findSmallestPeriod(input);

    std::cout << "最小周期为: " << smallestPeriod << std::endl;

    return 0;
}

解释说明

当我们说一个字符串具有周期性时，意味着该字符串可以由一个较短的子串重复多次组成。例如，字符串 "abcabcabc" 具有周期性，其周期为 "abc"，因为它可以重复三次来构建整个字符串。

这个C++程序的目标是找到给定字符串的最小周期。最小周期是能够将字符串重复多次以构建原始字符串的最短子串长度。下面我将逐步解释程序和算法的工作原理：

• 用户被要求输入一个字符串，该字符串的长度不超过80个字符。
• findSmallestPeriod 函数是用于查找最小周期的核心部分。它接受一个字符串作为参数，并返回最小周期的长度。
• 在 findSmallestPeriod 函数中，我们首先获取输入字符串的长度并将其存储在变量 n 中。
• 接下来，我们使用一个循环来尝试不同的周期长度 k，从1到字符串的长度 n。对于每个 k 值，我们检查是否可以通过重复长度为 k 的子串来构建原始字符串。
• 在循环中，我们首先检查 n 是否可以被 k 整除，因为只有在整除的情况下才可能存在周期性。
• 如果 n 可以被 k 整除，那么我们进一步检查是否可以通过重复 k 长度的子串来构建原始字符串。我们使用一个嵌套循环遍历字符串的每个字符，检查是否与其对应的周期位置上的字符相同。
• 如果所有的字符都匹配，那么我们就找到了一个周期，我们返回 k 作为最小周期的长度。
• 如果没有找到周期，我们继续尝试下一个 k 值，直到遍历所有可能的周期长度。
• 如果在整个循环中都没有找到周期，那么我们默认将字符串的长度 n 作为最小周期长度。
• 最后，程序输出找到的最小周期长度。

这个算法的时间复杂度是比较高的，因为它需要尝试多个周期长度。但是，对于较短的字符串，它仍然是一个合理的方法。如果字符串很长，可能需要考虑更高效的算法。这个程序提供了一个基本的示例，演示了如何找到字符串的最小周期。

时间复杂度：当我们谈论一个算法的时间复杂度时，实际上是在讨论这个算法需要多长时间来完成任务。可以将时间复杂度想象成一个度量标准，用来衡量不同算法在处理相同问题时，谁更快或更慢。
想象一下你和你的朋友在做同样的数学题，但你们使用了不同的方法。时间复杂度就像是一种方式，帮助你们比较谁的方法更快。
时间复杂度告诉我们，当输入的数据规模增加时，算法执行所需的时间会如何增加。一个具有较低时间复杂度的算法通常会更快，因为它可以在更短的时间内处理更多的数据。
举个例子，假设你和你的朋友都要计算从1加到100的和。你选择了直接相加的方法，而你的朋友选择了使用一个数学公式（如等差数列求和公式）。尽管两种方法都可以得到正确的答案，但使用公式的方法更快，因此它的时间复杂度更低。
所以，时间复杂度就是一种衡量算法执行速度的方式，它帮助我们选择最合适的算法来解决问题，特别是在处理大量数据时，能够帮助我们选择更高效的方法。

之前使用python里面的pygame可以很容易构建snake游戏，其实pygame后端也是封装了sdl库，所以pygame编写的snake，使用C++
SDL2编写应该很容易移植过来

不过我不想自己亲自编写，我想偷懒让人工智能帮我完成看看，结果表明要一次达成目标似乎也不是那么顺利
经过几次对话，好歹勉强实现了贪吃蛇的基础功能

第一次尝试

代码

#include <SDL.h>
#include <iostream>
#include <vector>
#include <cstdlib>
#include <ctime>

using namespace std;

// 定义游戏窗口的宽度和高度
const int SCREEN_WIDTH = 640;
const int SCREEN_HEIGHT = 480;

// 定义Snake的单元格大小
const int CELL_SIZE = 20;

// 定义Snake的初始长度
const int INITIAL_LENGTH = 5;

// 定义Snake的方向
enum class Direction { UP, DOWN, LEFT, RIGHT };

// 定义Snake的单元格结构体
struct Cell {
    int x, y;
};

// Snake类
class Snake {
public:
    Snake();
    void HandleInput(SDL_Event &e);
    void Move();
    bool CheckCollision();
    void Grow();
    void Render(SDL_Renderer* renderer);
private:
    vector<Cell> body;
    Direction direction;
};

Snake::Snake() {
    // 初始化Snake的位置和方向
    for (int i = 0; i < INITIAL_LENGTH; ++i) {
        body.push_back({SCREEN_WIDTH / 2 - i * CELL_SIZE, SCREEN_HEIGHT / 2});
    }
    direction = Direction::RIGHT;
}

void Snake::HandleInput(SDL_Event &e) {
    // 处理用户输入，改变Snake的方向
    if (e.type == SDL_KEYDOWN) {
        switch (e.key.keysym.sym) {
            case SDLK_UP:
                if (direction != Direction::DOWN)
                    direction = Direction::UP;
                break;
            case SDLK_DOWN:
                if (direction != Direction::UP)
                    direction = Direction::DOWN;
                break;
            case SDLK_LEFT:
                if (direction != Direction::RIGHT)
                    direction = Direction::LEFT;
                break;
            case SDLK_RIGHT:
                if (direction != Direction::LEFT)
                    direction = Direction::RIGHT;
                break;
        }
    }
}

void Snake::Move() {
    // 移动Snake的头部
    int newHeadX = body.front().x;
    int newHeadY = body.front().y;

    switch (direction) {
        case Direction::UP:
            newHeadY -= CELL_SIZE;
            break;
        case Direction::DOWN:
            newHeadY += CELL_SIZE;
            break;
        case Direction::LEFT:
            newHeadX -= CELL_SIZE;
            break;
        case Direction::RIGHT:
            newHeadX += CELL_SIZE;
            break;
    }

    // 添加新的头部
    body.insert(body.begin(), {newHeadX, newHeadY});
}

bool Snake::CheckCollision() {
    // 检查是否与自身相撞
    for (size_t i = 1; i < body.size(); ++i) {
        if (body[i].x == body.front().x && body[i].y == body.front().y) {
            return true;
        }
    }

    // 检查是否超出屏幕边界
    if (body.front().x < 0 || body.front().x >= SCREEN_WIDTH || body.front().y < 0 || body.front().y >= SCREEN_HEIGHT) {
        return true;
    }

    return false;
}

void Snake::Grow() {
    // Snake吃到食物时增加长度
    int tailX = body.back().x;
    int tailY = body.back().y;

    switch (direction) {
        case Direction::UP:
            tailY += CELL_SIZE;
            break;
        case Direction::DOWN:
            tailY -= CELL_SIZE;
            break;
        case Direction::LEFT:
            tailX += CELL_SIZE;
            break;
        case Direction::RIGHT:
            tailX -= CELL_SIZE;
            break;
    }

    body.push_back({tailX, tailY});
}

void Snake::Render(SDL_Renderer* renderer) {
    // 渲染Snake
    for (const Cell& cell : body) {
        SDL_Rect rect = {cell.x, cell.y, CELL_SIZE, CELL_SIZE};
        SDL_SetRenderDrawColor(renderer, 0, 255, 0, 255); // Snake颜色
        SDL_RenderFillRect(renderer, &rect);
    }
}

// 主程序
int main(int argc, char* args[]) {
    SDL_Init(SDL_INIT_VIDEO);
    SDL_Window* window = SDL_CreateWindow("Snake Game", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, SCREEN_WIDTH, SCREEN_HEIGHT, SDL_WINDOW_SHOWN);
    SDL_Renderer* renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED);
    srand(time(nullptr));

    Snake snake;

    // 游戏主循环
    bool quit = false;
    SDL_Event e;
    while (!quit) {
        while (SDL_PollEvent(&e) != 0) {
            if (e.type == SDL_QUIT) {
                quit = true;
            }
            snake.HandleInput(e);
        }

        // 移动Snake
        snake.Move();

        // 检查碰撞
        if (snake.CheckCollision()) {
            quit = true;
        }

        // 渲染
        SDL_SetRenderDrawColor(renderer, 0, 0, 0, 255); // 清空屏幕
        SDL_RenderClear(renderer);
        snake.Render(renderer);
        SDL_RenderPresent(renderer);

        // 控制游戏速度
        SDL_Delay(100);
    }

    SDL_DestroyRenderer(renderer);
    SDL_DestroyWindow(window);
    SDL_Quit();

    return 0;
}

运行结果，看起来不符合预期

第二次尝试

代码

#include <SDL.h>
#include <iostream>
#include <vector>
#include <cstdlib>
#include <ctime>

using namespace std;

const int SCREEN_WIDTH = 640;
const int SCREEN_HEIGHT = 480;
const int CELL_SIZE = 20;

enum class Direction { UP, DOWN, LEFT, RIGHT };

struct Cell {
    int x, y;
};

class Snake {
public:
    Snake();
    void HandleInput(SDL_Event &e);
    void Move();
    bool CheckCollision();
    void Grow();
    void Render(SDL_Renderer* renderer);
private:
    vector<Cell> body;
    Direction direction;
};

Snake::Snake() {
    body.push_back({SCREEN_WIDTH / 2, SCREEN_HEIGHT / 2});
    direction = Direction::RIGHT;
}

void Snake::HandleInput(SDL_Event &e) {
    if (e.type == SDL_KEYDOWN) {
        switch (e.key.keysym.sym) {
            case SDLK_UP:
                if (direction != Direction::DOWN)
                    direction = Direction::UP;
                break;
            case SDLK_DOWN:
                if (direction != Direction::UP)
                    direction = Direction::DOWN;
                break;
            case SDLK_LEFT:
                if (direction != Direction::RIGHT)
                    direction = Direction::LEFT;
                break;
            case SDLK_RIGHT:
                if (direction != Direction::LEFT)
                    direction = Direction::RIGHT;
                break;
        }
    }
}

void Snake::Move() {
    int newHeadX = body.front().x;
    int newHeadY = body.front().y;

    switch (direction) {
        case Direction::UP:
            newHeadY -= CELL_SIZE;
            break;
        case Direction::DOWN:
            newHeadY += CELL_SIZE;
            break;
        case Direction::LEFT:
            newHeadX -= CELL_SIZE;
            break;
        case Direction::RIGHT:
            newHeadX += CELL_SIZE;
            break;
    }

    body.insert(body.begin(), {newHeadX, newHeadY});
}

bool Snake::CheckCollision() {
    for (size_t i = 1; i < body.size(); ++i) {
        if (body[i].x == body.front().x && body[i].y == body.front().y) {
            return true;
        }
    }

    if (body.front().x < 0 || body.front().x >= SCREEN_WIDTH || body.front().y < 0 || body.front().y >= SCREEN_HEIGHT) {
        return true;
    }

    return false;
}

void Snake::Grow() {
    int tailX = body.back().x;
    int tailY = body.back().y;

    switch (direction) {
        case Direction::UP:
            tailY += CELL_SIZE;
            break;
        case Direction::DOWN:
            tailY -= CELL_SIZE;
            break;
        case Direction::LEFT:
            tailX += CELL_SIZE;
            break;
        case Direction::RIGHT:
            tailX -= CELL_SIZE;
            break;
    }

    body.push_back({tailX, tailY});
}

void Snake::Render(SDL_Renderer* renderer) {
    for (size_t i = 0; i < body.size(); ++i) {
        SDL_Rect rect = {body[i].x, body[i].y, CELL_SIZE, CELL_SIZE};
        if (i == 0) {
            SDL_SetRenderDrawColor(renderer, 255, 255, 0, 255); // Snake头部为黄色
        } else {
            SDL_SetRenderDrawColor(renderer, 0, 255, 0, 255); // Snake身体为绿色
        }
        SDL_RenderFillRect(renderer, &rect);
    }
}

int main(int argc, char* args[]) {
    SDL_Init(SDL_INIT_VIDEO);
    SDL_Window* window = SDL_CreateWindow("Snake Game", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, SCREEN_WIDTH, SCREEN_HEIGHT, SDL_WINDOW_SHOWN);
    SDL_Renderer* renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED);
    srand(time(nullptr));

    Snake snake;

    bool quit = false;
    SDL_Event e;
    while (!quit) {
        while (SDL_PollEvent(&e) != 0) {
            if (e.type == SDL_QUIT) {
                quit = true;
            }
            snake.HandleInput(e);
        }

        snake.Move();

        if (snake.CheckCollision()) {
            quit = true;
        }

        SDL_SetRenderDrawColor(renderer, 0, 0, 0, 255);
        SDL_RenderClear(renderer);
        snake.Render(renderer);
        SDL_RenderPresent(renderer);

        SDL_Delay(100);
    }

    SDL_DestroyRenderer(renderer);
    SDL_DestroyWindow(window);
    SDL_Quit();

    return 0;
}

结果貌似还是不符合预期

第三次尝试

代码

#include <SDL.h>
#include <iostream>
#include <vector>
#include <cstdlib>
#include <ctime>

using namespace std;

const int SCREEN_WIDTH = 640;
const int SCREEN_HEIGHT = 480;
const int CELL_SIZE = 20;

enum class Direction { UP, DOWN, LEFT, RIGHT };

struct Cell {
    int x, y;
};

class Snake {
public:
    Snake();
    void HandleInput(SDL_Event &e);
    void Move();
    bool CheckCollision();
    void Grow();
    void Render(SDL_Renderer* renderer);
    Cell GetHeadPosition();
private:
    vector<Cell> body;
    Direction direction;
};

Snake::Snake() {
    body.push_back({SCREEN_WIDTH / 2, SCREEN_HEIGHT / 2});
    direction = Direction::RIGHT;
}

void Snake::HandleInput(SDL_Event &e) {
    if (e.type == SDL_KEYDOWN) {
        switch (e.key.keysym.sym) {
            case SDLK_UP:
                if (direction != Direction::DOWN)
                    direction = Direction::UP;
                break;
            case SDLK_DOWN:
                if (direction != Direction::UP)
                    direction = Direction::DOWN;
                break;
            case SDLK_LEFT:
                if (direction != Direction::RIGHT)
                    direction = Direction::LEFT;
                break;
            case SDLK_RIGHT:
                if (direction != Direction::LEFT)
                    direction = Direction::RIGHT;
                break;
        }
    }
}

void Snake::Move() {
    int newHeadX = body.front().x;
    int newHeadY = body.front().y;

    switch (direction) {
        case Direction::UP:
            newHeadY -= CELL_SIZE;
            break;
        case Direction::DOWN:
            newHeadY += CELL_SIZE;
            break;
        case Direction::LEFT:
            newHeadX -= CELL_SIZE;
            break;
        case Direction::RIGHT:
            newHeadX += CELL_SIZE;
            break;
    }

    body.insert(body.begin(), {newHeadX, newHeadY});
}

bool Snake::CheckCollision() {
    for (size_t i = 1; i < body.size(); ++i) {
        if (body[i].x == body.front().x && body[i].y == body.front().y) {
            return true;
        }
    }

    if (body.front().x < 0 || body.front().x >= SCREEN_WIDTH || body.front().y < 0 || body.front().y >= SCREEN_HEIGHT) {
        return true;
    }

    return false;
}

void Snake::Grow() {
    // 在Snake的尾部增加一个单元格
    int tailX = body.back().x;
    int tailY = body.back().y;

    switch (direction) {
        case Direction::UP:
            tailY += CELL_SIZE;
            break;
        case Direction::DOWN:
            tailY -= CELL_SIZE;
            break;
        case Direction::LEFT:
            tailX += CELL_SIZE;
            break;
        case Direction::RIGHT:
            tailX -= CELL_SIZE;
            break;
    }

    body.push_back({tailX, tailY});
}

void Snake::Render(SDL_Renderer* renderer) {
    for (size_t i = 0; i < body.size(); ++i) {
        SDL_Rect rect = {body[i].x, body[i].y, CELL_SIZE, CELL_SIZE};
        if (i == 0) {
            SDL_SetRenderDrawColor(renderer, 255, 255, 0, 255); // Snake头部为黄色
        } else {
            SDL_SetRenderDrawColor(renderer, 0, 255, 0, 255); // Snake身体为绿色
        }
        SDL_RenderFillRect(renderer, &rect);
    }
}

Cell Snake::GetHeadPosition() {
    return body.front();
}

int main(int argc, char* args[]) {
    SDL_Init(SDL_INIT_VIDEO);
    SDL_Window* window = SDL_CreateWindow("Snake Game", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, SCREEN_WIDTH, SCREEN_HEIGHT, SDL_WINDOW_SHOWN);
    SDL_Renderer* renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED);
    srand(time(nullptr));

    Snake snake;

    // 初始化食物位置
    Cell food = {rand() % (SCREEN_WIDTH / CELL_SIZE) * CELL_SIZE, rand() % (SCREEN_HEIGHT / CELL_SIZE) * CELL_SIZE};

    bool quit = false;
    SDL_Event e;
    while (!quit) {
        while (SDL_PollEvent(&e) != 0) {
            if (e.type == SDL_QUIT) {
                quit = true;
            }
            snake.HandleInput(e);
        }

        snake.Move();

        if (snake.GetHeadPosition().x == food.x && snake.GetHeadPosition().y == food.y) {
            // Snake吃到食物时，增加长度并生成新的食物位置
            snake.Grow();
            food = {rand() % (SCREEN_WIDTH / CELL_SIZE) * CELL_SIZE, rand() % (SCREEN_HEIGHT / CELL_SIZE) * CELL_SIZE};
        }

        if (snake.CheckCollision()) {
            quit = true;
        }

        SDL_SetRenderDrawColor(renderer, 0, 0, 0, 255);
        SDL_RenderClear(renderer);
        snake.Render(renderer);

        // 渲染食物
        SDL_SetRenderDrawColor(renderer, 0, 255, 0, 255); // 食物为绿色
        SDL_Rect foodRect = {food.x, food.y, CELL_SIZE, CELL_SIZE};
        SDL_RenderFillRect(renderer, &foodRect);

        SDL_RenderPresent(renderer);

        SDL_Delay(100);
    }

    SDL_DestroyRenderer(renderer);
    SDL_DestroyWindow(window);
    SDL_Quit();

    return 0;
}

运行结果，依然不符合预期，真是糟糕

第四次尝试，看看

代码

#include <SDL.h>
#include <iostream>
#include <vector>
#include <cstdlib>
#include <ctime>

using namespace std;

const int SCREEN_WIDTH = 640;
const int SCREEN_HEIGHT = 480;
const int CELL_SIZE = 20;

enum class Direction { UP, DOWN, LEFT, RIGHT };

struct Cell {
    int x, y;
};

class Snake {
public:
    Snake();
    void HandleInput(SDL_Event &e);
    void Move();
    bool CheckCollision();
    void Grow();
    void Render(SDL_Renderer* renderer);
    Cell GetHeadPosition();
private:
    vector<Cell> body;
    Direction direction;
    bool growing;  // 用于标记是否吃到食物后需要增长
};

Snake::Snake() {
    body.push_back({SCREEN_WIDTH / 2, SCREEN_HEIGHT / 2});
    direction = Direction::RIGHT;
    growing = false;  // 初始化时不需要增长
}

void Snake::HandleInput(SDL_Event &e) {
    if (e.type == SDL_KEYDOWN) {
        switch (e.key.keysym.sym) {
            case SDLK_UP:
                if (direction != Direction::DOWN)
                    direction = Direction::UP;
                break;
            case SDLK_DOWN:
                if (direction != Direction::UP)
                    direction = Direction::DOWN;
                break;
            case SDLK_LEFT:
                if (direction != Direction::RIGHT)
                    direction = Direction::LEFT;
                break;
            case SDLK_RIGHT:
                if (direction != Direction::LEFT)
                    direction = Direction::RIGHT;
                break;
        }
    }
}

void Snake::Move() {
    int newHeadX = body.front().x;
    int newHeadY = body.front().y;

    switch (direction) {
        case Direction::UP:
            newHeadY -= CELL_SIZE;
            break;
        case Direction::DOWN:
            newHeadY += CELL_SIZE;
            break;
        case Direction::LEFT:
            newHeadX -= CELL_SIZE;
            break;
        case Direction::RIGHT:
            newHeadX += CELL_SIZE;
            break;
    }

    body.insert(body.begin(), {newHeadX, newHeadY});

    // 如果吃到食物，则不删除尾部，实现增长
    if (!growing) {
        body.pop_back();
    } else {
        growing = false;
    }
}

bool Snake::CheckCollision() {
    for (size_t i = 1; i < body.size(); ++i) {
        if (body[i].x == body.front().x && body[i].y == body.front().y) {
            return true;
        }
    }

    if (body.front().x < 0 || body.front().x >= SCREEN_WIDTH || body.front().y < 0 || body.front().y >= SCREEN_HEIGHT) {
        return true;
    }

    return false;
}

void Snake::Grow() {
    // 在Snake的尾部增加一个单元格
    int tailX = body.back().x;
    int tailY = body.back().y;

    switch (direction) {
        case Direction::UP:
            tailY += CELL_SIZE;
            break;
        case Direction::DOWN:
            tailY -= CELL_SIZE;
            break;
        case Direction::LEFT:
            tailX += CELL_SIZE;
            break;
        case Direction::RIGHT:
            tailX -= CELL_SIZE;
            break;
    }

    body.push_back({tailX, tailY});
    growing = true;  // 标记为需要增长
}

void Snake::Render(SDL_Renderer* renderer) {
    for (size_t i = 0; i < body.size(); ++i) {
        SDL_Rect rect = {body[i].x, body[i].y, CELL_SIZE, CELL_SIZE};
        if (i == 0) {
            SDL_SetRenderDrawColor(renderer, 255, 255, 0, 255); // Snake头部为黄色
        } else {
            SDL_SetRenderDrawColor(renderer, 0, 255, 0, 255); // Snake身体为绿色
        }
        SDL_RenderFillRect(renderer, &rect);
    }
}

Cell Snake::GetHeadPosition() {
    return body.front();
}

int main(int argc, char* args[]) {
    SDL_Init(SDL_INIT_VIDEO);
    SDL_Window* window = SDL_CreateWindow("Snake Game", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, SCREEN_WIDTH, SCREEN_HEIGHT, SDL_WINDOW_SHOWN);
    SDL_Renderer* renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED);
    srand(time(nullptr));

    Snake snake;

    // 初始化食物位置
    Cell food = {rand() % (SCREEN_WIDTH / CELL_SIZE) * CELL_SIZE, rand() % (SCREEN_HEIGHT / CELL_SIZE) * CELL_SIZE};

    bool quit = false;
    SDL_Event e;
    while (!quit) {
        while (SDL_PollEvent(&e) != 0) {
            if (e.type == SDL_QUIT) {
                quit = true;
            }
            snake.HandleInput(e);
        }

        snake.Move();

        if (snake.GetHeadPosition().x == food.x && snake.GetHeadPosition().y == food.y) {
            // Snake吃到食物时，增加长度并生成新的食物位置
            snake.Grow();
            food = {rand() % (SCREEN_WIDTH / CELL_SIZE) * CELL_SIZE, rand() % (SCREEN_HEIGHT / CELL_SIZE) * CELL_SIZE};
        }

        if (snake.CheckCollision()) {
            quit = true;
        }

        SDL_SetRenderDrawColor(renderer, 0, 0, 0, 255);
        SDL_RenderClear(renderer);
        snake.Render(renderer);

        // 渲染食物
        SDL_SetRenderDrawColor(renderer, 0, 255, 0, 255); // 食物为绿色
        SDL_Rect foodRect = {food.x, food.y, CELL_SIZE, CELL_SIZE};
        SDL_RenderFillRect(renderer, &foodRect);

        SDL_RenderPresent(renderer);

        SDL_Delay(100);
    }

    SDL_DestroyRenderer(renderer);
    SDL_DestroyWindow(window);
    SDL_Quit();

    return 0;
}

运行结果，看起来达到预期

透过这几次对话，我们可以看到要想快速达到预期的结果，提问非常关键，如果一开始就给出比较细致的说明，应该能够一次成功，需要试试！

透过比较几次代码的差异，也可以从中学习到程序bug产生的原因

新的编程工具使用，总是需要环境搭建

IDE + 库

SDL2_mixer-devel-2.6.3-mingw.zip

SDL2 Hello World版本

#include <SDL.h>
#include <iostream>
#include <SDL_ttf.h>

int main(int argc, char* argv[])
{
    // 初始化SDL
    if (SDL_Init(SDL_INIT_VIDEO) < 0) {
        std::cerr << "无法初始化SDL: " << SDL_GetError() << std::endl;
        return 1;
    }

    // 创建窗口
    SDL_Window* window = SDL_CreateWindow("Hello SDL", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, 800, 600, SDL_WINDOW_SHOWN);
    if (!window) {
        std::cerr << "无法创建窗口: " << SDL_GetError() << std::endl;
        SDL_Quit();
        return 1;
    }

    // 创建渲染器
    SDL_Renderer* renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED);
    if (!renderer) {
        std::cerr << "无法创建渲染器: " << SDL_GetError() << std::endl;
        SDL_DestroyWindow(window);
        SDL_Quit();
        return 1;
    }

    if (TTF_Init() == -1) {
        std::cerr << "无法初始化TTF库: " << TTF_GetError() << std::endl;
        SDL_Quit();
        return 1;
    }

    TTF_Font* font = TTF_OpenFont("Pacifico.ttf", 36);
    if (!font) {
        std::cerr << "无法加载字体: " << TTF_GetError() << std::endl;
        TTF_Quit();
        SDL_Quit();
        return 1;
    }




    // 渲染一些文本
    SDL_Surface* surface = SDL_GetWindowSurface(window);
    SDL_FillRect(surface, NULL, SDL_MapRGB(surface->format, 255, 255, 255));
    SDL_Color textColor = {255, 255, 255};
    SDL_Surface* textSurface = TTF_RenderText_Solid(font, "Hello, SDL!", textColor);
    SDL_Rect textRect = {200, 200, textSurface->w, textSurface->h};

    SDL_Texture* textTexture = SDL_CreateTextureFromSurface(renderer, textSurface);
    SDL_RenderCopy(renderer, textTexture, NULL, &textRect);

    SDL_RenderPresent(renderer);

    // 处理事件循环
    bool quit = false;
    SDL_Event event;
    while (!quit) {
        while (SDL_PollEvent(&event)) {
            if (event.type == SDL_QUIT) {
                quit = true;
            }
        }
    }

    // 清理资源
    TTF_CloseFont(font);
    TTF_Quit();

    SDL_DestroyTexture(textTexture);
    SDL_FreeSurface(textSurface);
    SDL_DestroyRenderer(renderer);
    SDL_DestroyWindow(window);
    SDL_Quit();

    return 0;
}

hello world详细解释

#include <SDL.h>
#include <iostream>

这两行是包含头文件的指令。第一行包含了SDL2的头文件，它是用于与SDL2库交互的必要头文件。第二行包含了C++标准库的头文件iostream，它用于在控制台输出错误信息。

int main(int argc, char* argv[]) {

这是C++程序的入口点。main 函数是程序运行的起始点。int argc 和 char* argv[] 用于传递命令行参数。

    // 初始化SDL
    if (SDL_Init(SDL_INIT_VIDEO) < 0) {
        std::cerr << "无法初始化SDL: " << SDL_GetError() << std::endl;
        return 1;
    }

这一部分初始化了SDL2库。SDL_Init(SDL_INIT_VIDEO) 函数初始化SDL2的视频子系统。如果初始化失败，会输出错误信息并返回1表示程序出错。

    // 创建窗口
    SDL_Window* window = SDL_CreateWindow("Hello SDL", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, 800, 600, SDL_WINDOW_SHOWN);
    if (!window) {
        std::cerr << "无法创建窗口: " << SDL_GetError() << std::endl;
        SDL_Quit();
        return 1;
    }

这一部分创建了一个窗口。SDL_CreateWindow 函数用于创建一个窗口，并指定窗口的标题、位置和大小。如果创建失败，会输出错误信息，然后清理SDL2并返回1。

    // 创建渲染器
    SDL_Renderer* renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED);
    if (!renderer) {
        std::cerr << "无法创建渲染器: " << SDL_GetError() << std::endl;
        SDL_DestroyWindow(window);
        SDL_Quit();
        return 1;
    }

这一部分创建了一个渲染器，用于在窗口上绘制图形。SDL_CreateRenderer 函数将渲染器与窗口关联起来。如果创建失败，会输出错误信息，然后清理窗口和SDL2，并返回1。

    // 渲染一些文本
    SDL_Surface* surface = SDL_GetWindowSurface(window);
    SDL_FillRect(surface, NULL, SDL_MapRGB(surface->format, 255, 255, 255));

这部分代码获取窗口表面并用白色填充整个窗口，以准备绘制文本。

    SDL_Color textColor = {0, 0, 0};
    SDL_Surface* textSurface = TTF_RenderText_Solid(font, "Hello, SDL!", textColor);
    SDL_Rect textRect = {200, 200, textSurface->w, textSurface->h};

这一部分定义了文本的颜色，并创建了一个包含文本的表面（textSurface）。你需要先定义一个字体（font），这里并没有包含在示例中。

    SDL_Texture* textTexture = SDL_CreateTextureFromSurface(renderer, textSurface);
    SDL_RenderCopy(renderer, textTexture, NULL, &textRect);
    SDL_RenderPresent(renderer);

这一部分将文本表面转换为纹理，并使用渲染器将文本绘制到窗口上，最后调用SDL_RenderPresent函数来更新窗口显示。

    // 处理事件循环
    bool quit = false;
    SDL_Event event;
    while (!quit) {
        while (SDL_PollEvent(&event)) {
            if (event.type == SDL_QUIT) {
                quit = true;
            }
        }
    }

这一部分处理SDL2的事件循环。它会一直运行，直到收到退出事件（如关闭窗口按钮）。

    // 清理资源
    SDL_DestroyTexture(textTexture);
    SDL_FreeSurface(textSurface);
    SDL_DestroyRenderer(renderer);
    SDL_DestroyWindow(window);
    SDL_Quit();

    return 0;
}

最后，这部分清理了所有分配的资源，包括纹理、表面、渲染器、窗口，并调用SDL_Quit来关闭SDL2库。最后，返回0表示程序成功结束。

上面的代码bug

仔细看我们并没有定义font？

解决方法：

• 首先，你需要在代码中包含SDL2_ttf头文件：

  #include <SDL_ttf.h>

• 然后，在主函数的开头，初始化TTF库：

  if (TTF_Init() == -1) {
    std::cerr << "无法初始化TTF库: " << TTF_GetError() << std::endl;
    SDL_Quit();
    return 1;
  }

• 接下来，你需要加载一个TrueType字体文件，例如：

  TTF_Font* font = TTF_OpenFont("path/to/your/font.ttf", 36);
  if (!font) {
    std::cerr << "无法加载字体: " << TTF_GetError() << std::endl;
    TTF_Quit();
    SDL_Quit();
    return 1;
  }

  请确保将 "path/to/your/font.ttf" 替换为你自己字体文件的路径。

最后，在绘制文本部分，使用这个字体来渲染文本：

SDL_Surface* textSurface = TTF_RenderText_Solid(font, "Hello, SDL!", textColor);

这样，你就可以使用指定的字体来渲染文本了。请不要忘记在程序结束时清理字体资源：

TTF_CloseFont(font);
TTF_Quit();

例子工程代码：

• hello world SDL2-helloworld.zip
• 加在图片 SDL2_imageSDL2-pictures.zip
• 播放mp3 SDL2_mixer SDL2-mixer.zip
• snake game