C++ 调用SDL“；IMG“负载”；第二次的结果是；EXC“坏”访问（代码=EXC“I386”GPFLT）“；

我使用Xcode 8.3.3在MacOS 10.12上运行它，SDL2通过自制作为Dylibs安装

下面是一些轻微的修改

我刚刚添加了第二个纹理

gTexture2

和函数

loadMedia2

，以便能够重现问题。第二次执行

IMG_Load

时，它会崩溃，并显示以下消息：

EXC_BAD_ACCESS (code=EXC_I386_GPFLT)

寻找如何解决“一般保护故障”问题也没有让我走得更远，碰撞似乎发生在SDL内部。我可能真的误解了导致这个问题的原因，我非常欢迎任何帮助

真正令人困惑的是，它并不总是崩溃，只有大约3次中的2次

崩溃似乎发生在

SDL\u AllocFormat\u REAL（）内部


下面是代码示例

/*This source code copyrighted by Lazy Foo' Productions (2004-2015)
 and may not be redistributed without written permission.*/

//Using SDL, SDL_image, standard IO, and strings
#include <SDL.h>
#include <SDL_image.h>
#include <stdio.h>
#include <string>

//Screen dimension constants
const int SCREEN_WIDTH = 640;
const int SCREEN_HEIGHT = 480;

//Starts up SDL and creates window
bool init();

//Loads media
bool loadMedia();

//Frees media and shuts down SDL
void close();

//Loads individual image as texture
SDL_Texture* loadTexture( std::string path );

//The window we'll be rendering to
SDL_Window* gWindow = NULL;

//The window renderer
SDL_Renderer* gRenderer = NULL;

//Current displayed texture
SDL_Texture* gTexture = NULL;
SDL_Texture* gTexture2 = NULL;


bool init()
{
    //Initialization flag
    bool success = true;

    //Initialize SDL
    if( SDL_Init( SDL_INIT_VIDEO ) < 0 )
    {
        printf( "SDL could not initialize! SDL Error: %s\n", SDL_GetError() );
        success = false;
    }
    else
    {
        //Set texture filtering to linear
        if( !SDL_SetHint( SDL_HINT_RENDER_SCALE_QUALITY, "1" ) )
        {
            printf( "Warning: Linear texture filtering not enabled!" );
        }

        //Create window
        gWindow = SDL_CreateWindow( "SDL Tutorial", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, SCREEN_WIDTH, SCREEN_HEIGHT, SDL_WINDOW_SHOWN );
        if( gWindow == NULL )
        {
            printf( "Window could not be created! SDL Error: %s\n", SDL_GetError() );
            success = false;
        }
        else
        {
            //Create renderer for window
            gRenderer = SDL_CreateRenderer( gWindow, -1, SDL_RENDERER_ACCELERATED );
            if( gRenderer == NULL )
            {
                printf( "Renderer could not be created! SDL Error: %s\n", SDL_GetError() );
                success = false;
            }
            else
            {
                //Initialize renderer color
                SDL_SetRenderDrawColor( gRenderer, 0xFF, 0xFF, 0xFF, 0xFF );

                //Initialize PNG loading
                int imgFlags = IMG_INIT_PNG;
                if( !( IMG_Init( imgFlags ) & imgFlags ) )
                {
                    printf( "SDL_image could not initialize! SDL_image Error: %s\n", IMG_GetError() );
                    success = false;
                }
            }
        }
    }

    return success;
}

bool loadMedia()
{
    //Loading success flag
    bool success = true;

    //Load PNG texture
    gTexture = loadTexture( "../assets/player.png" );
    if( gTexture == NULL )
    {
        printf( "Failed to load texture image!\n" );
        success = false;
    }

    return success;
}

bool loadMedia2()
{
    //Loading success flag
    bool success = true;

    //Load PNG texture
    gTexture2 = loadTexture( "../assets/scene_main/background.png" );
    if( gTexture == NULL )
    {
        printf( "Failed to load texture image!\n" );
        success = false;
    }

    return success;
}

void close()
{
    //Free loaded image
    SDL_DestroyTexture( gTexture );
    SDL_DestroyTexture( gTexture2 );
    gTexture = NULL;
    gTexture2 = NULL;        

    //Destroy window
    SDL_DestroyRenderer( gRenderer );
    SDL_DestroyWindow( gWindow );
    gWindow = NULL;
    gRenderer = NULL;

    //Quit SDL subsystems
    IMG_Quit();
    SDL_Quit();
}

SDL_Texture* loadTexture( std::string path )
{
    //The final texture
    SDL_Texture* newTexture = NULL;

    //Load image at specified path
    SDL_Surface* loadedSurface = IMG_Load( path.c_str() );
    if( loadedSurface == NULL )
    {
        printf( "Unable to load image %s! SDL_image Error: %s\n", path.c_str(), IMG_GetError() );
    }
    else
    {
        //Create texture from surface pixels
        newTexture = SDL_CreateTextureFromSurface( gRenderer, loadedSurface );
        if( newTexture == NULL )
        {
            printf( "Unable to create texture from %s! SDL Error: %s\n", path.c_str(), SDL_GetError() );
        }

        //Get rid of old loaded surface
        SDL_FreeSurface( loadedSurface );
    }

    return newTexture;
}

int main( int argc, char* args[] )
{
    //Start up SDL and create window
    if( !init() )
    {
        printf( "Failed to initialize!\n" );
    }
    else
    {
        //Load media
        if( !loadMedia() || !loadMedia2() )
        {
            printf( "Failed to load media!\n" );
        }
        else
        {   
            //Main loop flag
            bool quit = false;

            //Event handler
            SDL_Event e;

            //While application is running
            while( !quit )
            {
                //Handle events on queue
                while( SDL_PollEvent( &e ) != 0 )
                {
                    //User requests quit
                    if( e.type == SDL_QUIT )
                    {
                        quit = true;
                    }
                }

                //Clear screen
                SDL_RenderClear( gRenderer );

                //Render texture to screen
                SDL_RenderCopy( gRenderer, gTexture, NULL, NULL );

                //Update screen
                SDL_RenderPresent( gRenderer );
            }
        }
    }

    //Free resources and close SDL
    close();

    return 0;
}   

/*此源代码受Lazy Foo’Productions（2004-2015）版权所有
未经书面许可，不得重新发布*/
//使用SDL、SDL_图像、标准IO和字符串
#包括
#包括
#包括
#包括
//屏幕尺寸常数
屏幕宽度=640；
屏幕上的常数=480；
//启动SDL并创建窗口
bool init（）；
//加载媒体
bool loadMedia（）；
//释放媒体并关闭SDL
无效关闭（）；
//将单个图像加载为纹理
SDL_纹理*加载纹理（标准：：字符串路径）；
//我们将渲染到的窗口
SDL_窗口*gWindow=NULL；
//窗口渲染器
SDL_渲染器*gRenderer=NULL；
//当前显示的纹理
SDL_纹理*gTexture=NULL；
SDL_纹理*gTexture2=NULL；
boolinit（）
{
//初始化标志
布尔成功=真；
//初始化SDL
if（SDL_Init（SDL_Init_视频）<0）
{
printf（“SDL无法初始化！SDL错误：%s\n”，SDL_GetError（））；
成功=错误；
}
其他的
{
//将纹理过滤设置为线性
如果（！SDL_SetHint（SDL_HINT_RENDER_SCALE_QUALITY，“1”））
{
printf（“警告：线性纹理过滤未启用！”）；
}
//创建窗口
gWindow=SDL_CreateWindow（“SDL教程”，SDL_WINDOWPOS_未定义，SDL_WINDOWPOS_未定义，屏幕宽度，屏幕高度，显示SDL_窗口）；
if（gWindow==NULL）
{
printf（“无法创建窗口！SDL错误：%s\n”，SDL_GetError（））；
成功=错误；
}
其他的
{
//为窗口创建渲染器
gRenderer=SDL_CreateRenderer（gWindow，-1，SDL_RENDERER_加速）；
if（gRenderer==NULL）
{
printf（“无法创建渲染器！SDL错误：%s\n”，SDL_GetError（））；
成功=错误；
}
其他的
{
//初始化渲染器颜色
SDL_SetRenderDrawColor（灰色，0xFF，0xFF，0xFF，0xFF）；
//初始化PNG加载
int imgFlags=IMG_INIT_PNG；
if（！（IMG_Init（imgFlags）和imgFlags））
{
printf（“SDL_映像无法初始化！SDL_映像错误：%s\n”，IMG_GetError（））；
成功=错误；
}
}
}
}
回归成功；
}
bool loadMedia（）
{
//加载成功标志
布尔成功=真；
//加载PNG纹理
gTexture=loadTexture（“../assets/player.png”）；
if（gTexture==NULL）
{
printf（“加载纹理图像失败！\n”）；
成功=错误；
}
回归成功；
}
bool loadMedia2（）
{
//加载成功标志
布尔成功=真；
//加载PNG纹理
gTexture2=loadTexture（“../assets/scene_main/background.png”）；
if（gTexture==NULL）
{
printf（“加载纹理图像失败！\n”）；
成功=错误；
}
回归成功；
}
无效关闭（）
{
//自由加载图像
SDL_破坏纹理（gTexture）；
SDL_破坏纹理（gTexture2）；
gTexture=NULL；
gTexture2=NULL；
//破坏窗口
SDL_（格伦德尔）；
SDL_（格温多）；
gWindow=NULL；
grender=NULL；
//退出SDL子系统
IMG_Quit（）；
SDL_退出（）；
}
SDL_纹理*加载纹理（标准：：字符串路径）
{
//最后的纹理
SDL_纹理*newTexture=NULL；
//在指定路径加载图像
SDL_Surface*loadedSurface=IMG_Load（path.c_str（））；
如果（loadedSurface==NULL）
{
printf（“无法加载图像%s！SDL_图像错误：%s\n”，path.c_str（），IMG_GetError（））；
}
其他的
{
//从表面像素创建纹理
newTexture=SDL_CreateTextureFromSurface（更大，加载的表面）；
if（newTexture==NULL）
{
printf（“无法从%s创建纹理！SDL错误：%s\n”，path.c_str（），SDL_GetError（））；
}
//去除旧的加载曲面
SDL_自由表面（加载表面）；
}
返回新文本；
}
int main（int argc，char*args[]
{
//启动SDL并创建窗口
如果（！init（））
{
printf（“初始化失败！\n”）；
}
其他的
{
//加载媒体
如果（！loadMedia（）| |！loadMedia 2（））
{
printf（“加载媒体失败！\n”）；
}
其他的
{   
//主循环标志
bool-quit=false；
//事件处理程序
SDL_事件e；
//当应用程序运行时
而（！退出）
{
//处理队列上的事件
while（SDL_PollEvent（&e）！=0）
{
//用户请求退出
如果（e.type==SDL\u退出）
{
退出=真；
}
}
//清屏
SDL_RenderClear（gRenderer）；
//将纹理渲染到屏幕
SDL_渲染副本（格伦德）
SDL_DestroyTexture( gTexture );
SDL_DestroyTexture( gTexture2 );

gTexture = NULL;
gTexture2 = NULL;

std::string().swap(path);