C++ SDL_GetRenderInfo崩溃

以下程序一直运行，直到调用SDL_GetRenderInfo（在函数RenderInit（）中），然后在SDL_GetError可以执行任何操作之前停止工作。使用空SDL_渲染器指针替换全局_渲染器不会导致崩溃，并且会得到预期的SDL错误

#include <iostream>
#include <list>
#include "SDL.h"
using namespace std;
//global variables:
bool run = true; // whether or not the program should be running

int global_window_width = 50; //width of window in tiles

int global_window_height = 35; //height of window in tiles

SDL_Window* global_window = NULL; //points to primary window

SDL_Renderer* global_renderer = NULL; //points to renderer for main window

SDL_RendererInfo* global_renderer_info = NULL; //points to info about above renderer once it's initialized

SDL_Texture* spritesheet = NULL; //holds the spritesheet

SDL_Event event; //for holding currently in-handling event

//function declarations:
int init();  //initialize SDL

int windowInit(); //initialize window

int renderInit(); //create renderers

int viewInit(); //manages all window, rendering, etc stuff

int loadSpritesheet(); //loads spritesheet

void cleanup(); //free up memory, etc

void dispatchEvent(); //main event handling

//function definitions:
int init()
{
    if ( SDL_Init(SDL_INIT_EVERYTHING) !=0 )
    {
        cout << "could not initialize SDL. " << SDL_GetError();
        return 1;
    }

    return 0;
}

int windowInit()
{
    global_window = SDL_CreateWindow("roguelike",
                                  SDL_WINDOWPOS_UNDEFINED,
                                  SDL_WINDOWPOS_UNDEFINED,
                                  global_window_width * 10,
                                  global_window_height * 10,
                                  SDL_WINDOW_SHOWN);
    if(global_window == NULL)
    {
        cout << "could create window. " << SDL_GetError();
        return 1;
    }
    return 0;
}

int renderInit()
{
        global_renderer = SDL_CreateRenderer(global_window,
                                             -1,
                                             SDL_RENDERER_TARGETTEXTURE | SDL_RENDERER_ACCELERATED );
        if (global_renderer == NULL)
        {
            cout << "could not create renderer" << SDL_GetError();
            return 1;
        }
        SDL_SetRenderDrawColor(global_renderer,0xFF,0xFF,0xFF,0xFF);
        if (SDL_GetRendererInfo(global_renderer, global_renderer_info) != 0)
        {
            cout << "could not get renderer info" << SDL_GetError();
            return 1;
        }

        return 0;
}

int viewInit()
{
    if (windowInit() == 1)
    {
        return 1;
    }
    else if(renderInit() == 1)
    {
        return 1;
    }
    else if(loadSpritesheet() == 1)
    {
        return 1;
    }
    return 0;
}

int loadSpritesheet()
{
    SDL_Surface* tempsurf = NULL; //using surface to get image initially, but since surfaces use cpu rendering we switch to textures immediately

    tempsurf = SDL_LoadBMP("spritesheet.bmp"); //puts image in the surface

    if (tempsurf == NULL)
    {
        cout << "failed to load spritesheet";
        SDL_FreeSurface(tempsurf); //we don't need tempsurf anymore
        return 1;
    }
    spritesheet = SDL_CreateTextureFromSurface(global_renderer, tempsurf);
    if (spritesheet == NULL)
    {
        cout << "failed to create spritesheet texture";
        SDL_FreeSurface(tempsurf); //we don't need tempsurf anymore
        return 1;
    }
    SDL_FreeSurface(tempsurf); //we don't need tempsurf anymore
    return 0;
}

void cleanup()
{
    SDL_DestroyWindow(global_window);
    global_window = NULL;
    SDL_DestroyRenderer(global_renderer);
    global_renderer = NULL;
    SDL_DestroyTexture(spritesheet);
    spritesheet = NULL;
    global_renderer_info = NULL;
    SDL_Quit();
}

void dispatchEvent()
{
    SDL_PollEvent(&event); //stores current event information
    switch(event.type)
    {
        case SDL_QUIT:
        {
            run = false;
            break;
        }
    }
}
//classes:

class Layer // each layer holds visuals for a certain subset of what is to be displayed; environment, HUD, menu, etc.
{
    Layer(){};
};

class Camera  //renders environment, ui, etc in a series of layers
{
        int width, height; //in tiles
        SDL_Texture* texture_draw; //texture the camera draws to and sends to be displayed
        list<Layer*> layer_list; //list of layers to be rendered, back --> front
    public:
        Camera(int x, int y, SDL_Renderer* renderer): width(x), height(y) //(width, height, renderer for camera to use)
        {
            texture_draw = SDL_CreateTexture(global_renderer,global_renderer_info->texture_formats[0] , SDL_TEXTUREACCESS_TARGET, 10*width, 10*height);
        };
};

//main loop
int main(int argc, char *argv[]) //main function, needed by SDL
{
    if(init() == 0)
    {
        if(viewInit() == 0)
        {
            while(run)
            {
                dispatchEvent();

            }
        }
    }
    cleanup();
    return 0;
}

#包括
#包括
#包括“SDL.h”
使用名称空间std；
//全局变量：
bool run=true；//程序是否应该运行
int全局窗口宽度=50//瓷砖窗的宽度
int全局窗口高度=35//瓦片窗的高度
SDL_Window*全局_Window=NULL//指向主窗口
SDL_渲染器*全局_渲染器=NULL//指向主窗口的渲染器
SDL_渲染器信息*全局_渲染器_信息=NULL//初始化后指向有关上述渲染器的信息
SDL_纹理*精灵表=空//保持精神状态
SDL_事件//用于当前正在处理事件的保持
//函数声明：
int init（）//初始化SDL
int windowInit（）//初始化窗口
int renderInit（）//创建渲染器
int viewInit（）//管理所有窗口、渲染等内容
int loadSpritesheet（）//加载精灵表
空洞清理（）//释放内存等
作废dispatchEvent（）//主要事件处理
//函数定义：
int init（）
{
if（SDL_Init（SDL_Init_EVERYTHING）！=0）
{
cout您要求
SDL\u getrenderinfo
将渲染器信息写入指向的位置
global\u renderer\u info
为空。写入空会导致分段错误。这应该是预期的行为

正确的代码应该为渲染器信息分配内存（最好在堆栈上或全局区域），并写入该位置，例如：

SDL_RendererInfo info = {0};
SDL_GetRendererInfo(global_renderer, &info);
// ... use info fields

修正者：我没有将全局渲染器信息声明为指向SDL渲染器信息的指针，而是直接声明了对象，并相应地更改了其余代码。
使用调试器，应该很容易发现问题。可能是。不幸的是，我没有调试器经验。这是一个学习的好机会。DebuGgging是每个程序员都需要做的事情。你能推荐一些资源吗？为什么在
init（）
中调用空
SDL\u渲染器的
SDL\u SetRenderDrawColor（）
？