题目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

高手可以从代码推导出语言的一般语法规则，我们尝试从这个Chatgpt提供的ATM实现，学习C++一些基础概念

使用C++ 实现ATM模拟程序

ChatGPT快速给出了一个很简单的模拟程序，可以显示余额，存款，取款基本操作，当然没有很华丽的程序界面，纯粹是命令行的操作

    #include <iostream>
    #include <iomanip>
    
    using namespace std;
    
    class ATM {
    private:
        double balance;
    
    public:
        ATM(double initialBalance) : balance(initialBalance) {}
    
        double getBalance() const {
            return balance;
        }
    
        void deposit(double amount) {
            if (amount > 0) {
                balance += amount;
                cout << "存款成功。当前余额为 $" << fixed << setprecision(2) << balance << endl;
            } else {
                cout << "无效的存款金额。" << endl;
            }
        }
    
        void withdraw(double amount) {
            if (amount > 0 && amount <= balance) {
                balance -= amount;
                cout << "取款成功。当前余额为 $" << fixed << setprecision(2) << balance << endl;
            } else {
                cout << "无效的取款金额或余额不足。" << endl;
            }
        }
    };
    
    int main() {
        double initialBalance;
        cout << "欢迎使用ATM模拟程序!" << endl;
        cout << "请输入您的初始余额: $";
        cin >> initialBalance;
    
        ATM atm(initialBalance);
    
        int choice;
        double amount;
    
        while (true) {
            cout << "请选择操作:" << endl;
            cout << "1. 查询余额" << endl;
            cout << "2. 存款" << endl;
            cout << "3. 取款" << endl;
            cout << "4. 退出" << endl;
            cin >> choice;
    
            switch (choice) {
                case 1:
                    cout << "当前余额为 $" << fixed << setprecision(2) << atm.getBalance() << endl;
                    break;
                case 2:
                    cout << "请输入存款金额: $";
                    cin >> amount;
                    atm.deposit(amount);
                    break;
                case 3:
                    cout << "请输入取款金额: $";
                    cin >> amount;
                    atm.withdraw(amount);
                    break;
                case 4:
                    cout << "感谢使用ATM模拟程序，再见!" << endl;
                    return 0;
                default:
                    cout << "无效的选项，请重新选择。" << endl;
                    break;
            }
        }
    
        return 0;
    }

这个简单的ATM模拟程序允许用户查询余额、存款、取款以及退出。用户可以根据菜单中的选项进行操作，并得到相应的反馈。请注意，这只是一个基本的示例程序，实际的ATM系统会更复杂，包括更多的功能和安全性考虑。希望这个示例有助于你理解如何编写一个简单的ATM模拟程序。

代码解释

这段代码是一个简单的C++程序，它模拟了一个基本的ATM（自动取款机）程序。ATM程序允许用户查询余额、存款、取款和退出。下面是对这段代码的解释：

• 引入头文件和命名空间：

    #include <iostream>
    #include <iomanip>
    
    using namespace std;

  这里引入了两个C++标准库的头文件， 用于输入和输出， 用于格式化输出。using namespace std; 语句是为了简化代码，允许在代码中直接使用标准命名空间 std 中的函数和对象，而无需前缀 std::。

• 定义ATM类

    class ATM {
    private:
        double balance;
    
    public:
        ATM(double initialBalance) : balance(initialBalance) {}
    
        double getBalance() const {
            return balance;
        }
    
        void deposit(double amount) {
            if (amount > 0) {
                balance += amount;
                cout << "存款成功。当前余额为 $" << fixed << setprecision(2) << balance << endl;
            } else {
                cout << "无效的存款金额。" << endl;
            }
        }
    
        void withdraw(double amount) {
            if (amount > 0 && amount <= balance) {
                balance -= amount;
                cout << "取款成功。当前余额为 $" << fixed << setprecision(2) << balance << endl;
            } else {
                cout << "无效的取款金额或余额不足。" << endl;
            }
        }
    };

这里定义了一个 ATM 类，该类包含了账户余额（balance）和三个公有成员函数：ATM 构造函数，getBalance 函数用于查询余额，deposit 函数用于存款，withdraw 函数用于取款。构造函数初始化账户余额。

• main函数

    int main() {
        double initialBalance;
        cout << "欢迎使用ATM模拟程序!" << endl;
        cout << "请输入您的初始余额: $";
        cin >> initialBalance;
        ATM atm(initialBalance);
    
        int choice;
        double amount;
    
        while (true) {
            cout << "请选择操作:" << endl;
            cout << "1. 查询余额" << endl;
            cout << "2. 存款" << endl;
            cout << "3. 取款" << endl;
            cout << "4. 退出" << endl;
            cin >> choice;
    
            switch (choice) {
                case 1:
                    cout << "当前余额为 $" << fixed << setprecision(2) << atm.getBalance() << endl;
                    break;
                case 2:
                    cout << "请输入存款金额: $";
                    cin >> amount;
                    atm.deposit(amount);
                    break;
                case 3:
                    cout << "请输入取款金额: $";
                    cin >> amount;
                    atm.withdraw(amount);
                    break;
                case 4:
                    cout << "感谢使用ATM模拟程序，再见!" << endl;
                    return 0;
                default:
                    cout << "无效的选项，请重新选择。" << endl;
                    break;
            }
        }
    
        return 0;
    }

• main函数首先询问用户输入初始余额，并根据用户输入创建一个 ATM 对象。
• 然后，使用一个无限循环来提供菜单选项，用户可以选择查询余额、存款、取款或退出。
• 用户的选择由 cin 输入获取，并使用 switch 语句进行相应的处理。
• 如果用户选择查询余额，ATM 对象的 getBalance 函数会被调用并显示当前余额。
• 如果用户选择存款或取款，程序会要求用户输入金额，并调用相应的 deposit 或 withdraw 函数来更新余额。
• 如果用户选择退出，程序会显示感谢消息并退出。
• 如果用户输入无效的选项，程序会输出相应的错误消息。

这个程序模拟了一个简单的ATM功能，用户可以进行基本的查询和交易操作

拓展？

如果我们要给这个程序增加操作历史的查询功能该怎么搞？

C++中，你可以使用cout和cin进行格式化输出和输入。下面是几个示例，演示如何使用格式化控制符来控制输出和输入的格式。

格式化输出示例：

• 输出浮点数时指定小数点位数：

    #include <iostream>
    #include <iomanip>
    
    using namespace std;
    
    int main() {
        double number = 123.45678;
        cout << fixed << setprecision(2) << number << endl; // 输出: 123.46
        return 0;
    }

• 设置输出字段宽度：

    #include <iostream>
    #include <iomanip>
    
    using namespace std;
    
    int main() {
        int num1 = 123;
        int num2 = 45678;
        cout << setw(10) << num1 << setw(10) << num2 << endl; // 输出: "       123     45678"
        return 0;
    }

  格式化输入示例

• 从用户输入中读取整数：

    #include <iostream>
    
    using namespace std;
    
    int main() {
        int num;
        cout << "请输入一个整数: ";
        cin >> num;
        cout << "您输入的整数是: " << num << endl;
        return 0;
    }

• 从用户输入中读取浮点数：

  #include <iostream>
  #include <iomanip>
  
    using namespace std;
    
    int main() {
        double num;
        cout << "请输入一个浮点数: ";
        cin >> num;
        cout << "您输入的浮点数是: " << fixed << setprecision(2) << num << endl;
        return 0;
    }

  不同数制输出格式

• 十进制数制输出

    #include <iostream>
    
    using namespace std;
    
    int main() {
        int decimalNumber = 123;
        cout << "十进制数：" << decimalNumber << endl; // 输出：十进制数：123
        return 0;
    }

• 八进制数制输出：

    #include <iostream>
    #include <iomanip>
    
    using namespace std;
    
    int main() {
        int octalNumber = 0123; // 八进制数，前面加0表示
        cout << "八进制数：" << oct << octalNumber << endl; // 输出：八进制数：123
        return 0;
    }

• 十六进制数制输出：

    #include <iostream>
    #include <iomanip>
    
    using namespace std;
    
    int main() {
        int hexadecimalNumber = 0x1A; // 十六进制数，前面加0x表示
        cout << "十六进制数：" << hex << uppercase << hexadecimalNumber << endl; // 输出：十六进制数：1A
        return 0;
    }

  cin输入出错或者异常处理

  在C++中，可以使用异常处理机制来处理cin输入的错误或异常情况。通常，cin可能会在以下情况下引发异常或错误：

• 非法输入数据类型： 用户输入的数据类型与期望的不匹配。
• 流状态错误： 例如，当文件结束或文件读取错误时。
• 输入缓冲区溢出： 用户输入的数据超出了程序预期的范围。

• 以下是一些处理cin输入异常的方法，使用了C++的异常处理机制：

    #include <iostream>
    #include <stdexcept>
    
    using namespace std;
    
    int main() {
        int num;
    
        try {
            cout << "请输入一个整数: ";
            if (!(cin >> num)) {
                throw runtime_error("输入无效"); // 抛出运行时异常
            }
    
            // 处理正常输入
            cout << "您输入的整数是: " << num << endl;
        } catch (const exception& e) {
            cerr << "发生异常: " << e.what() << endl;
            // 清除输入缓冲区
            cin.clear();
            cin.ignore(numeric_limits<streamsize>::max(), '\n');
        }
    
        return 0;
    }

  在上述示例中，我们使用了try和catch块来处理异常情况。如果用户输入的不是整数，cin会抛出一个异常，然后我们在catch块中捕获并处理异常，输出错误消息并清除输入缓冲区。

  在异常处理中，你可以采取适当的措施，例如重新请求用户输入、输出错误消息、记录错误等，以便更好地处理cin输入引发的异常。

  请注意，异常处理是一种处理输入错误的一种方法，但不是唯一的方法。你还可以使用其他方式来验证和处理输入，根据具体需求来选择最合适的方法。