C++ 为什么我的C++；使用构造函数时程序崩溃？

我正在按照“learnopengl.com”教程制作一个简单的OpenGL程序。现在代码应该只显示一个橙色三角形

我的代码：

屏幕管理器

\ifndef屏幕\u管理器\u H
#定义屏幕管理器
#定义GLEW_静态
#包括
#包括
#包括
#包括“Input.h”
#包括“Renderer.h”
类屏幕管理器
{
公众：
电影经理（作废）；
bool iscloserequest（）；
void render（）；
无效更新（）；
无效处置（）；
私人：
GLFWwindow*窗口；
渲染器渲染器；
};
#恩迪夫

ScreenManager.cpp

#包括“ScreenManager.h”
ScreenManager:：ScreenManager（无效）
{
//初始化GLFW库
glfwInit（）；
//将opengl版本指定为3
glfwWindowHint（GLFW_上下文_版本_专业，3）；
glfwWindowHint（GLFW_上下文_版本_小调，3）；
//将opengl配置文件指定为核心配置文件
glfwWindowHint（GLFW_OPENGL_配置文件、GLFW_OPENGL_核心配置文件）；
//禁用调整大小
glfwWindowHint（GLFW_可调整大小，GL_为FALSE）；
//创建窗口对象
窗口=glfwCreateWindow（800600，“测试”，空PTR，空PTR）；
//使GL上下文成为线程中的活动上下文
glfwMakeContextCurrent（窗口）；
//错误检查
如果（窗口==NULL）{
std:：cout当您在构造函数中调用
init
时，它是在
ScreenManager
的成员构造过程中调用的，该过程发生在执行
ScreenManager
的构造函数主体之前

此时，OpenGL尚未初始化，这就是您崩溃的原因。
您需要显示实际创建渲染器实例和/或调用init（）函数的代码（例如main（）函数）。请尝试提供尽可能小的完整可编译代码示例来说明您的问题（目前，您已经包含了许多可能会分散人们注意力的东西，这些东西会分散人们的帮助）。在调用init（）之前，代码也没有合法的方法可以避免使用呈现器构造函数-因此您的描述表明您遗漏了相关信息。我现在知道了，我正在调用呈现器构造函数（在ScreenManager.h中）在ScreenManager构造函数中初始化opengl之前：哦，现在我明白了，为什么我不这么简单：P，谢谢你的帮助：D
#ifndef SCREEN_MANAGER_H
#define SCREEN_MANAGER_H

#define GLEW_STATIC

#include <GL\glew.h>
#include <GLFW\glfw3.h>
#include <iostream>
#include "Input.h"
#include "Renderer.h"

class ScreenManager
{
    public:
        ScreenManager(void);
        bool isCloseRequested();
        void render();
        void update();
        void dispose();
        private:
        GLFWwindow* window;
        Renderer renderer;
};

#endif

#include "ScreenManager.h"

ScreenManager::ScreenManager(void)
{
    // Initialize GLFW library
    glfwInit();

    // Specify the opengl version to 3
    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);

    // Specify opengl profile to core profile
    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);

    // Disable resizing
    glfwWindowHint(GLFW_RESIZABLE, GL_FALSE);

    // Create the window object
    window = glfwCreateWindow(800, 600, "test", nullptr, nullptr);

    // Make the GL context the active context in the thread
    glfwMakeContextCurrent(window);

    // Error check
    if(window==NULL){
        std::cout << "failed to create GLFW window :( " << std::endl;
        dispose();
    }

    // Make sure that GLEW use modern techniques to manage opengl functionality
    glewExperimental = GL_TRUE;

    // Initialize GLEW and check for errors
    if(glewInit() != GLEW_OK){
        std::cout << "failed to initialize glew :( " << std::endl;
    }

    // Specify opengl viewport => bottom left coordinates and window size
    glViewport(0, 0, 800, 600);

    // Register the events for GLFW => currently :keyboard
    Input input(window);

    renderer.init();
}

// Check if window is closed
bool ScreenManager::isCloseRequested(){
    if(glfwWindowShouldClose(window))
        return true;
    return false;
}

// Clear screen and swap buffers
void ScreenManager::render(){
    glClearColor(0, 0, 0, 0);
    glClear(GL_COLOR_BUFFER_BIT);

    renderer.render();

    glfwSwapBuffers(window);
}

// Check for events (registered events)
void ScreenManager::update(){
    glfwPollEvents();
}

void ScreenManager::dispose(){
    glfwTerminate();
}

#ifndef RENDERER_H
#define RENDERER_H

#define GLEW_STATIC
#include <GL\glew.h>
#include <iostream>

class Renderer
{
    public:
        Renderer(void);
        void init();
        void render();

    private:
        void testShape();
        GLuint createVertexShader(GLuint &shader);
        GLuint createFragmentShader(GLuint &shader);
        void createShaderProgram(GLuint &program);
};

#endif

#include "Renderer.h"

GLuint program;
GLuint vertexShader;
GLuint fragmentShader;
GLuint VAO;

Renderer::Renderer(){
    //init();
}

void Renderer::init(){
    testShape();

    createShaderProgram(program);
}

void Renderer::render(){
    glUseProgram(program);
    glBindVertexArray(VAO);
    glDrawArrays(GL_TRIANGLES, 0, 3);
    glBindVertexArray(0);
}

void Renderer::testShape(){
    GLfloat vertices[] = {
        -0.5f, -0.5f, 0.0f,
         0.5f, -0.5f, 0.0f,
         0.0f,  0.5f, 0.0f
    };

    GLuint VBO;
    glGenBuffers(1, &VBO);
    glGenVertexArrays(1, &VAO);

    glBindVertexArray(VAO);

    glBindBuffer(GL_ARRAY_BUFFER, VBO);
    glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);

    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3* sizeof(GLfloat), (GLvoid*)0);
    glEnableVertexAttribArray(0);

    glBindBuffer(VBO, 0);

    glBindVertexArray(0);
}

GLuint Renderer::createVertexShader(GLuint &shader){
    const GLchar* vertexShaderSource =
        "#version 330 core\n"
        "layout (location = 0) in vec3 position;\n"
        "void main(){\n"
        "    gl_Position = vec4(position.x, position.y, position.z, 1.0);\n"
        "}";

    vertexShader = glCreateShader(GL_VERTEX_SHADER);

    glShaderSource(vertexShader, 1, &vertexShaderSource, NULL);
    glCompileShader(vertexShader);

    GLint success;
    GLchar info[512];
    glGetShaderiv(vertexShader, GL_COMPILE_STATUS, &success);

    if(!success){
        glGetShaderInfoLog(vertexShader, 512, NULL, info);
        std::cout << "couldn't compile shader :(/n" << info << std::endl;
    }
    return vertexShader;
}

GLuint Renderer::createFragmentShader(GLuint &shader){
    const GLchar* fragmentShaderSource =
        "#version 330 core\n"
        "out vec4 color;\n"
        "void main(){\n"
        "    color = vec4(1.0, 0.5, 0.2, 0);\n"
        "}";

    fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);

    glShaderSource(fragmentShader, 1, &fragmentShaderSource, NULL);
    glCompileShader(fragmentShader);

    GLint success;
    GLchar info[512];
    glGetShaderiv(fragmentShader, GL_COMPILE_STATUS, &success);

    if(!success){
        glGetShaderInfoLog(fragmentShader, 512, NULL, info);
        std::cout << "couldn't compile shader :(\n" << info << "\n" << std::endl;
    }

    return fragmentShader;
}

void Renderer::createShaderProgram(GLuint &program){
    program = glCreateProgram();

    glAttachShader(program, createVertexShader(vertexShader));
    glAttachShader(program, createFragmentShader(fragmentShader));
    glLinkProgram(program);

    GLint success;
    GLchar info[512];

    glGetProgramiv(program, GL_LINK_STATUS, &success);

    if(!success){
        glGetProgramInfoLog(program, 512, NULL, info);
        std::cout << "couldn't link program :(\n" << info << "\n" << std::endl;
    }

    glDeleteShader(vertexShader);
    glDeleteShader(fragmentShader);
}