OpenGL 3.3 C++ 런타임 오류 '벡터 첨자가 범위를 벗어남'

Question

내 프로그램이 잘 컴파일되지만 실행하려고 할 때 이상한 오류가 발생합니다. 오류 사진이 포함되어 있습니다.

:

http://postimage.org/image/i6ernf8d7/

여기 http://postimage.org/image/dvywy86xf/full/

내 소스 코드 : 또한 나는이 소스 코드는 여기 http://www.opengl-tutorial.org/beginners-tutorials/tutorial-2-the-first-triangle/

오류 사진을 볼 온라인의 OpenGL 튜토리얼이라고 언급하고 싶습니다

조각 쉐이더

(210)

버텍스 쉐이더

#version 330 core 

// Input vertex data, different for all executions of this shader. 
layout(location = 0) in vec3 vertexPosition_modelspace; 

void main(){ 

    gl_Position.xyz = vertexPosition_modelspace; 
    gl_Position.w = 1.0; 

} 

shader.hpp

#include <stdio.h> 
#include <string> 
#include <vector> 
#include <fstream> 
#include <GL/glew.h> 

GLuint LoadShaders(const char * vertex_file_path, const char * fragment_file_path){ 

    // Create the shaders 
    GLuint VertexShaderID = glCreateShader(GL_VERTEX_SHADER); 
    GLuint FragmentShaderID = glCreateShader(GL_FRAGMENT_SHADER); 

    // Read the Vertex Shader code from the file 
    std::string VertexShaderCode; 
    std::ifstream VertexShaderStream(vertex_file_path, std::ios::in); 
    if(VertexShaderStream.is_open()) 
    { 
     std::string Line = ""; 
     while(getline(VertexShaderStream, Line)) 
      VertexShaderCode += "\n" + Line; 
     VertexShaderStream.close(); 
    } 

    // Read the Fragment Shader code from the file 
    std::string FragmentShaderCode; 
    std::ifstream FragmentShaderStream(fragment_file_path, std::ios::in); 
    if(FragmentShaderStream.is_open()){ 
     std::string Line = ""; 
     while(getline(FragmentShaderStream, Line)) 
      FragmentShaderCode += "\n" + Line; 
     FragmentShaderStream.close(); 
    } 

    GLint Result = GL_FALSE; 
    int InfoLogLength; 

    // Compile Vertex Shader 
    printf("Compiling shader : %s\n", vertex_file_path); 
    char const * VertexSourcePointer = VertexShaderCode.c_str(); 
    glShaderSource(VertexShaderID, 1, &VertexSourcePointer , NULL); 
    glCompileShader(VertexShaderID); 

    // Check Vertex Shader 
    glGetShaderiv(VertexShaderID, GL_COMPILE_STATUS, &Result); 
    glGetShaderiv(VertexShaderID, GL_INFO_LOG_LENGTH, &InfoLogLength); 
    std::vector<char> VertexShaderErrorMessage(InfoLogLength); 
    glGetShaderInfoLog(VertexShaderID, InfoLogLength, NULL, &VertexShaderErrorMessage[0]); 
    fprintf(stdout, "%s\n", &VertexShaderErrorMessage[0]); 

    // Compile Fragment Shader 
    printf("Compiling shader : %s\n", fragment_file_path); 
    char const * FragmentSourcePointer = FragmentShaderCode.c_str(); 
    glShaderSource(FragmentShaderID, 1, &FragmentSourcePointer , NULL); 
    glCompileShader(FragmentShaderID); 

    // Check Fragment Shader 
    glGetShaderiv(FragmentShaderID, GL_COMPILE_STATUS, &Result); 
    glGetShaderiv(FragmentShaderID, GL_INFO_LOG_LENGTH, &InfoLogLength); 
    std::vector<char> FragmentShaderErrorMessage(InfoLogLength); 
    glGetShaderInfoLog(FragmentShaderID, InfoLogLength, NULL, &FragmentShaderErrorMessage[0]); 
    fprintf(stdout, "%s\n", &FragmentShaderErrorMessage[0]); 

    // Link the program 
    fprintf(stdout, "Linking program\n"); 
    GLuint ProgramID = glCreateProgram(); 
    glAttachShader(ProgramID, VertexShaderID); 
    glAttachShader(ProgramID, FragmentShaderID); 
    glLinkProgram(ProgramID); 

    // Check the program 
    glGetProgramiv(ProgramID, GL_LINK_STATUS, &Result); 
    glGetProgramiv(ProgramID, GL_INFO_LOG_LENGTH, &InfoLogLength); 
    std::vector<char> ProgramErrorMessage(glm::max(InfoLogLength, int(1))); 
    glGetProgramInfoLog(ProgramID, InfoLogLength, NULL, &ProgramErrorMessage[0]); 
    fprintf(stdout, "%s\n", &ProgramErrorMessage[0]); 

    glDeleteShader(VertexShaderID); 
    glDeleteShader(FragmentShaderID); 

    return ProgramID; 
} 

내가 지금 어떤 조언이 내가 놓친 경우 ++ OpenGL을하고 C와 좋은 경험이없는

#include <stdio.h> 
#include <stdlib.h> 

#include <GL/glew.h> 
#include <GL/glfw.h> 
#include <glm/glm.hpp> 
using namespace glm; 

#include <iostream> 
using namespace std; 

#include "shader.hpp" 

int main() 
{ 

    if(!glfwInit()) 
    { 
     fprintf(stderr, "Failed to initialize GLFW\n"); 
     return -1; 
    } 

    glfwOpenWindowHint(GLFW_FSAA_SAMPLES, 4); // 4x antialiasing 
    glfwOpenWindowHint(GLFW_OPENGL_VERSION_MAJOR, 3); // We want OpenGL 3.3 
    glfwOpenWindowHint(GLFW_OPENGL_VERSION_MINOR, 2); 
    glfwOpenWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE); //We don't want the old OpenGL 

    // Open a window and create its OpenGL context 
    if(!glfwOpenWindow(1024, 768, 0,0,0,0, 32,0, GLFW_WINDOW)) 
    { 
     fprintf(stderr, "Failed to open GLFW window\n"); 
     glfwTerminate(); 
     return -1; 
    } 
    else 
    { 
     glfwSetWindowTitle("Tutorial 01"); 
    } 

    // Initialize GLEW 
    glewExperimental=true; // Needed in core profile 
    if (glewInit() != GLEW_OK) { 
     fprintf(stderr, "Failed to initialize GLEW\n"); 
     return -1; 
    } 



    glfwEnable(GLFW_STICKY_KEYS); 


    glClearColor(0.3f, 0.5f, 0.9f, 0.0f); 

    GLuint VertexArrayID; 
    glGenVertexArrays(1, &VertexArrayID); 
    glBindVertexArray(VertexArrayID); 

    // Create and compile our GLSL program from the shaders 
    GLuint programID = LoadShaders("vertex.shader", "fragment.shader"); 


    static const GLfloat g_vertex_buffer_data[] = { 
     -1.0f, -1.0f, 0.0f, 
     1.0f, -1.0f, 0.0f, 
     0.0f, 1.0f, 0.0f, 
    }; 

    GLuint vertexbuffer; 
    glGenBuffers(1, &vertexbuffer); 
    glBindBuffer(GL_ARRAY_BUFFER, vertexbuffer); 
    glBufferData(GL_ARRAY_BUFFER, sizeof(g_vertex_buffer_data), g_vertex_buffer_data, GL_STATIC_DRAW); 



    do{ 

     // Clear the screen 
     glClear(GL_COLOR_BUFFER_BIT); 

     // Use our shader 
     glUseProgram(programID); 

     // 1rst attribute buffer : vertices 
     glEnableVertexAttribArray(0); 
     glBindBuffer(GL_ARRAY_BUFFER, vertexbuffer); 
     glVertexAttribPointer(
      0,     // attribute 0. No particular reason for 0, but must match the layout in the shader. 
      3,     // size 
      GL_FLOAT,   // type 
      GL_FALSE,   // normalized? 
      0,     // stride 
      (void*)0   // array buffer offset 
     ); 

     // Draw the triangle ! 
     glDrawArrays(GL_TRIANGLES, 0, 3); // 3 indices starting at 0 -> 1 triangle 

     glDisableVertexAttribArray(0); 

     // Swap buffers 
     glfwSwapBuffers(); 

    } // Check if the ESC key was pressed or the window was closed 
    while(glfwGetKey(GLFW_KEY_ESC) != GLFW_PRESS && 
    glfwGetWindowParam(GLFW_OPENED)); 


    // Close OpenGL window and terminate GLFW 
    glfwTerminate(); 

    // Cleanup VBO 
    glDeleteBuffers(1, &vertexbuffer); 
    glDeleteVertexArrays(1, &VertexArrayID); 

    return 0; 
} 

MAIN.CPP 무엇인가 크게 감사 할 것입니다.

Answer 1

47 번째 줄의 벡터 인덱스가 범위를 벗어났습니다. 디버깅 할 때 벡터의 크기가 예상 한 것과 같은지 확인하십시오.

첫 번째 요소의 주소를 가져 오는 대신 data()을 사용하는 것이 좋습니다. 벡터가 비어있는 경우 대신

&VertexShaderErrorMessage[0] 

의

VertexShaderErrorMessage.data() 

그러나,이 문제가 해결되지 않습니다.