C++ SDL/OpenGL双缓冲内存泄漏

因此，我一直在尝试使用SDL和OpenGL为游戏制作自己的迷你引擎，主要游戏逻辑包含在一个singleton类中。但就我的一生而言，我无法弄清楚引擎的这个示例部分是如何出现内存泄漏的，尽管我非常确定每当我调用SDL_GL_SwapBuffers时都会发生内存泄漏。每隔两三秒，泄漏量约为4K。我使用的是SDL1.3；请帮我找到漏洞，过去一周我都快疯了

main模块.h

\ifndef主模块
#定义主模块
///包括
#包括“SDL/SDL.h”
#包括“SDL/SDL_opengl.h”
#包括
///定义语句（屏幕元素）
#定义主模块\u宽度800
#定义主模块高度600
#定义MAINMODULE_标题“MAINMODULE”
///定义语句（OpenGL内存使用）
#定义主模块\u红色\u尺寸8
#定义主模块\u绿色\u尺寸8
#定义主模块\u蓝色\u尺寸8
#定义主模块α尺寸8
#定义主模块缓冲区大小32
#定义主模块\u深度\u尺寸16
#定义MAINMODULE_DOUBLEBUFFER 1//1以启用
#定义MAINMODULE_标志SDL_OPENGL
///定义语句（OpenGL元素）
#定义主模块\u CLEARCOLOR 1.0f、1.0f、1.0f、1.0f
#定义主模块\u着色器模型GL\u平滑
#定义主模块\u深度\u测试0//1以启用
类主模块{
private://Constructor/deconstructor
main模块（）；
~main模块（）；
私有类变量
静态MainModule*\u Instance；//模块的单例实例。
静态int _Width；//游戏屏幕的宽度。
静态int _Height；//游戏屏幕的高度。
静态std:：string _Caption；//游戏屏幕标题/标题。
静态SDL_Surface*_screensface；//由窗口表示的游戏屏幕。
静态SDL_事件*_事件；//事件，如鼠标/按键输入。
静态布尔_已初始化；//引擎是否已初始化？
静态布尔_正在运行；//发动机是否正在运行？
public://Get/Set函数
静态内联int-Width（）{return\u-Width；}
静态内联int Height（）{return\u Height；}
静态内联std:：string Caption（）{return\u Caption；}
静态内联bool已初始化（）{return\u已初始化；}
静态内联bool IsRunning（）{return\u IsRunning；}
静态void SetCaption（std:：string caption）；
公共类函数
静态实例（）；
静态void解构实例（）；
静态void InitializeModule（）；
静态void RunGameLogic（）；//更新和呈现游戏信息。
};
#endif//main模块

MainModule.ccp

///包括
#包括“MainModule.h”
#包括
//静态变量声明
MainModule*MainModule:：_实例=0；
int main模块：：_Width=main模块_Width；
int主模块：：_高度=主模块_高度；
std:：string MainModule:：_Caption=MainModule_Caption；
SDL_表面*主模块：：_屏幕表面=0；
SDL_事件*主模块：：_事件=0；
布尔主模块：：IsInitialized=false；
布尔主模块：：_IsRunning=false；
///构造器/解构器
MainModule:：MainModule（）{}
MainModule:：~MainModule（）{
如果（_事件！=0）删除_事件；
如果（_屏幕表面！=0）SDL_自由表面（_屏幕表面）；
SDL_退出（）；
}
///设置函数
void MainModule:：SetCaption（std:：string caption）
{u Caption=Caption；if（_初始化）SDL_WM_SetCaption（_Caption.c_str（），0）；}
///类函数
void MainModule:：ConstructInstance（）
{if（_Instance==0）_Instance=new MainModule（）；}
void MainModule:：DeconstructInstance（）
{if（_Instance！=0）{delete_Instance；_Instance=0；}}
void MainModule:：InitializeModule（）{
ConstructInstance（）；//如果以前没有创建ConstructInstance函数，请创建一个实例。
if（_Instance==0）{printf（“MainModule实例未正确创建。/n”）；return；}
//初始化SDL。
if（SDL_Init（SDL_Init_EVERYTHING）！=0）{printf（“SDL初始化错误：%s/n”，SDL_GetError（））；return；}
//设置OpenGL内存使用情况。
SDL_GL_设置属性（SDL_GL_红色_大小、主模块红色_大小）；
SDL_GL_设置属性（SDL_GL_绿色_大小、主模块绿色_大小）；
SDL_GL_设置属性（SDL_GL_蓝色_大小、主模块蓝色_大小）；
SDL_GL_SetAttribute（SDL_GL_ALPHA_大小、主模块ALPHA_大小）；
SDL_GL_设置属性（SDL_GL_缓冲区大小、主模块缓冲区大小）；
SDL_GL_设置属性（SDL_GL_深度_大小、主模块深度_大小）；
SDL_GL_SetAttribute（SDL_GL_DOUBLEBUFFER，主模块DOUBLEBUFFER）；
//创建屏幕和窗口。
_屏幕表面=SDL_设置视频模式（主模块宽度、主模块高度、主模块缓冲区大小、主模块标志）；
如果（_ScreenSurface==0）{printf（“ScreenSurface未正确创建。/n”）；返回；}
SDL_WM_SetCaption（_Caption.c_str（），0）；
（主模块深度测试==1）？glEnable（GL深度测试）：glDisable（GL深度测试）；
glClearColor（主模块_CLEARCOLOR）；
glShadeModel（GL_平滑）；
_IsInitialized=true；
_IsRunning=true；
_事件=新的SDL_事件（）；
}
void MainModule:：RunGameLogic（）{
while（SDL_PollEvent（_Event））{//事件处理循环
开关（_事件->类型）{
案例SDL_退出：//退出游戏
{u IsRunning=false；break；}
案例SDL_活动事件：
{break；}
case SDL_KEYDOWN://键盘按下
{break；}
case SDL_KEYUP://键盘向上按
{break；}
case SDL_MOUSEMOTION://鼠标移动
{break；}
case SDL_MOUSEBUTTONDOWN://鼠标按下
{break；}
case SDL_MOUSEBUTTONUP://鼠标按钮向上
{break；}
}
}
//渲染逻辑
（主模块深度测试==1）？glClear（GL颜色缓冲区位）glClear（GL颜色缓冲区位）：glClear（GL颜色缓冲区位）；
SDL_GL_SwapBuffers（）；
}
///入口点f
#ifndef MAINMODULE_H
#define MAINMODULE_H

/// Includes
#include "SDL/SDL.h"
#include "SDL/SDL_opengl.h"
#include <string>

/// Define Statements (Screen elements)
#define MAINMODULE_WIDTH 800
#define MAINMODULE_HEIGHT 600
#define MAINMODULE_CAPTION "MainModule"

/// Define Statements (OpenGL memory usage)
#define MAINMODULE_RED_SIZE 8
#define MAINMODULE_GREEN_SIZE 8
#define MAINMODULE_BLUE_SIZE 8
#define MAINMODULE_ALPHA_SIZE 8
#define MAINMODULE_BUFFER_SIZE 32
#define MAINMODULE_DEPTH_SIZE 16
#define MAINMODULE_DOUBLEBUFFER 1 // 1 to Enable
#define MAINMODULE_FLAGS SDL_OPENGL

/// Define Statements (OpenGL elements)
#define MAINMODULE_CLEARCOLOR 1.0f, 1.0f, 1.0f, 1.0f
#define MAINMODULE_SHADEMODEL GL_SMOOTH
#define MAINMODULE_DEPTH_TEST 0 // 1 to Enable

class MainModule {

    private: // Constructor/Deconsctuctor

        MainModule();
        ~MainModule();

    private: // Class Variables

        static MainModule* _Instance;       // Singleton instance of the module.

        static int _Width;                  // Width of the game screen.
        static int _Height;                 // Height of the game screen.
        static std::string _Caption;        // Game screen caption/title.
        static SDL_Surface* _ScreenSurface; // Game screen as represented by the window.
        static SDL_Event* _Event;   // Events such as mouse/key input.

        static bool _IsInitialized;         // Has the engine been initialized?
        static bool _IsRunning;             // Is the engine running?

    public: // Get/Set Functions

        static inline int Width() { return _Width; }
        static inline int Height() { return _Height; }
        static inline std::string Caption() { return _Caption; }

        static inline bool IsInitialized() { return _IsInitialized; }
        static inline bool IsRunning() { return _IsRunning; }

        static void SetCaption(std::string caption);

    public: // Class Functions

        static void ConstructInstance();
        static void DeconstructInstance();

        static void InitializeModule();
        static void RunGameLogic();                         // Updates and renders game information.

};

#endif // MAINMODULE_H

/// Includes
#include "MainModule.h"
#include <iostream>

// Static Variable Declarations
MainModule* MainModule::_Instance = 0;
int MainModule::_Width = MAINMODULE_WIDTH;
int MainModule::_Height = MAINMODULE_HEIGHT;
std::string MainModule::_Caption = MAINMODULE_CAPTION;
SDL_Surface* MainModule::_ScreenSurface = 0;
SDL_Event* MainModule::_Event = 0;
bool MainModule::_IsInitialized = false;
bool MainModule::_IsRunning = false;

/// Constructor/Deconstructor
MainModule::MainModule() { }

MainModule::~MainModule() { 
    if (_Event != 0) delete _Event;
    if (_ScreenSurface != 0) SDL_FreeSurface(_ScreenSurface);
    SDL_Quit();
}

/// Set Functions
void MainModule::SetCaption(std::string caption)
{ _Caption = caption; if (_IsInitialized) SDL_WM_SetCaption(_Caption.c_str(), 0); }

/// Class Functions
void MainModule::ConstructInstance()
{ if (_Instance == 0) _Instance = new MainModule(); }

void MainModule::DeconstructInstance()
{ if (_Instance != 0) { delete _Instance; _Instance = 0; } }

void MainModule::InitializeModule() {
    ConstructInstance(); // Create an instance if the ConstructInstance function wasn't created before.
    if (_Instance == 0) { printf("MainModule instance not created properly./n"); return; } 

    // Initialize SDL.
    if (SDL_Init(SDL_INIT_EVERYTHING) != 0) { printf("SDL Initialization error: %s/n", SDL_GetError()); return; }

    // Set OpenGL memory usage.
    SDL_GL_SetAttribute(SDL_GL_RED_SIZE, MAINMODULE_RED_SIZE);
    SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, MAINMODULE_GREEN_SIZE);
    SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, MAINMODULE_BLUE_SIZE);
    SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE, MAINMODULE_ALPHA_SIZE);
    SDL_GL_SetAttribute(SDL_GL_BUFFER_SIZE, MAINMODULE_BUFFER_SIZE);
    SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, MAINMODULE_DEPTH_SIZE);
    SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, MAINMODULE_DOUBLEBUFFER);

    // Creates the screen and window.
    _ScreenSurface = SDL_SetVideoMode(MAINMODULE_WIDTH, MAINMODULE_HEIGHT, MAINMODULE_BUFFER_SIZE, MAINMODULE_FLAGS);
    if (_ScreenSurface == 0) { printf("ScreenSurface not created properly./n"); return; }
    SDL_WM_SetCaption(_Caption.c_str(), 0);

    (MAINMODULE_DEPTH_TEST == 1) ? glEnable(GL_DEPTH_TEST) : glDisable(GL_DEPTH_TEST);

    glClearColor(MAINMODULE_CLEARCOLOR);
    glShadeModel(GL_SMOOTH);

    _IsInitialized = true;
    _IsRunning = true;
    _Event = new SDL_Event();
}

void MainModule::RunGameLogic() {
    while (SDL_PollEvent(_Event)) { // Event handling loop
        switch (_Event->type) {
            case SDL_QUIT: // Exits out of game
            { _IsRunning = false; break; }
            case SDL_ACTIVEEVENT:
            { break; }
            case SDL_KEYDOWN: // Keyboard press down
            { break; }
            case SDL_KEYUP: // Keyboard press up
            { break; }
            case SDL_MOUSEMOTION: // Mouse movement
            { break; }
            case SDL_MOUSEBUTTONDOWN: // Mouse button down
            { break; }
            case SDL_MOUSEBUTTONUP: // Mouse button up
            { break; }
        }
    }

    // Rendering logic
    (MAINMODULE_DEPTH_TEST == 1) ? glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT) : glClear(GL_COLOR_BUFFER_BIT);

    SDL_GL_SwapBuffers();
}

/// Entry point for the program
int main(int argc, char** argv) {
    MainModule::InitializeModule();
    if (MainModule::IsInitialized()) { // If the modules initialized sucessfully
        while (MainModule::IsRunning()) { MainModule::RunGameLogic(); }
    }
    MainModule::DeconstructInstance();

    return 0;
}