在C语言中使用SDL2时如何减少函数参数实现代码抽象？

1. 核心方案：用结构体封装全局游戏状态 #

这是C语言里替代C++类最常用的方式——把所有需要在输入、更新、渲染流程间共享的数据（SDL窗口/渲染器、游戏逻辑数据、输入状态、时钟信息等）打包到一个结构体中，通过指针传递给各个函数，避免零散参数堆砌。

示例代码：

#include <SDL2/SDL.h>

// 封装所有游戏状态的结构体
typedef struct {
    SDL_Window* window;
    SDL_Renderer* renderer;
    SDL_Event event;
    int is_running;
    // 游戏逻辑数据
    int player_x;
    int player_y;
    Uint32 last_frame_time;
} GameState;

// 初始化游戏状态
void init_game(GameState* state) {
    SDL_Init(SDL_INIT_VIDEO);
    state->window = SDL_CreateWindow("SDL Game", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, 800, 600, 0);
    state->renderer = SDL_CreateRenderer(state->window, -1, SDL_RENDERER_ACCELERATED);
    state->is_running = 1;
    state->player_x = 400;
    state->player_y = 300;
    state->last_frame_time = SDL_GetTicks();
}

// 输入处理：仅接收GameState指针
void handle_input(GameState* state) {
    while (SDL_PollEvent(&state->event)) {
        if (state->event.type == SDL_QUIT) {
            state->is_running = 0;
        }
        const Uint8* keys = SDL_GetKeyboardState(NULL);
        if (keys[SDL_SCANCODE_LEFT]) state->player_x -= 5;
        if (keys[SDL_SCANCODE_RIGHT]) state->player_x += 5;
    }
}

// 游戏逻辑更新
void update_game(GameState* state) {
    Uint32 current_time = SDL_GetTicks();
    float delta_time = (current_time - state->last_frame_time) / 1000.0f;
    state->last_frame_time = current_time;
    // 基于delta_time实现帧率无关逻辑
}

// 渲染流程
void render_game(GameState* state) {
    SDL_SetRenderDrawColor(state->renderer, 0, 0, 0, 255);
    SDL_RenderClear(state->renderer);
    
    SDL_SetRenderDrawColor(state->renderer, 255, 0, 0, 255);
    SDL_Rect player = {state->player_x - 25, state->player_y - 25, 50, 50};
    SDL_RenderFillRect(state->renderer, &player);
    
    SDL_RenderPresent(state->renderer);
}

int main() {
    GameState state;
    init_game(&state);
    
    while (state.is_running) {
        handle_input(&state);
        update_game(&state);
        render_game(&state);
    }
    
    SDL_DestroyRenderer(state.renderer);
    SDL_DestroyWindow(state.window);
    SDL_Quit();
    return 0;
}

如果项目极小，也可以把GameState设为全局变量，这样函数连指针都不用传，但要注意全局变量会提升代码耦合度，不适合中大型项目。

2. 进阶模块化：用函数指针封装模块逻辑 #

如果游戏有多个独立模块（菜单、关卡、战斗等），可以把每个模块的输入/更新/渲染函数和私有状态打包成结构体，实现类似“类”的多态效果，进一步降低耦合。

示例代码：

// 定义通用模块接口
typedef struct GameModule {
    void* state; // 模块私有状态
    void (*handle_input)(void* state);
    void (*update)(void* state);
    void (*render)(void* state);
    void (*cleanup)(void* state);
} GameModule;

// 菜单模块私有状态
typedef struct {
    GameState* global_state;
    int selected_option;
} MenuState;

void menu_input(void* state) {
    MenuState* menu = (MenuState*)state;
    // 基于global_state处理菜单输入
}

void menu_update(void* state) {
    MenuState* menu = (MenuState*)state;
    // 更新菜单逻辑
}

void menu_render(void* state) {
    MenuState* menu = (MenuState*)state;
    // 渲染菜单UI
}

void menu_cleanup(void* state) {
    free(state);
}

// 创建菜单模块
GameModule create_menu_module(GameState* global_state) {
    MenuState* menu_state = malloc(sizeof(MenuState));
    menu_state->global_state = global_state;
    menu_state->selected_option = 0;
    
    return (GameModule){
        .state = menu_state,
        .handle_input = menu_input,
        .update = menu_update,
        .render = menu_render,
        .cleanup = menu_cleanup
    };
}

// 主循环中切换模块
int main() {
    GameState global_state;
    init_game(&global_state);
    
    GameModule current_module = create_menu_module(&global_state);
    
    while (global_state.is_running) {
        current_module.handle_input(current_module.state);
        current_module.update(current_module.state);
        current_module.render(current_module.state);
        
        // 示例：按回车切换到游戏模块
        // current_module = create_game_module(&global_state);
    }
    
    current_module.cleanup(current_module.state);
    // 清理全局状态...
    return 0;
}

关键注意事项 #

• 结构体仅存放跨流程共享的必要数据，避免职责混乱。
• 始终传递结构体指针而非副本，避免性能开销。
• 使用模块式方案时，务必在切换模块时清理旧模块的私有状态，防止内存泄漏。

内容的提问来源于stack exchange，提问作者Dr-Galunga