Program not entering the main()

Question

So, I am doing an assignment in OpenGL and C++. I am writing a code to draw the mandelbrot set. But the problem is that the code has no compiler errors, but as soon as I run the program, it crashes. Here is the code:

#define GLEW_STATIC
#include <GL\glew.h>
#include <GLFW\glfw3.h>
#include <iostream>
#include <cmath>
#include "Shader.h"
using namespace std;

// Tamanho da Janela
GLuint screenWidth = 800, screenHeight = 600;

void mandelbrotSet(GLfloat vertices[]);

int main() {
    const GLint numOfPositions = 5 * 800 * 600;
    GLint numOfPixels = screenWidth * screenHeight;

    glfwInit();
    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
    glfwWindowHint(GLFW_SAMPLES, 4); // 4 Samples de anti-aliasing
    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
    glfwWindowHint(GLFW_RESIZABLE, GL_FALSE);

    GLFWwindow* window = glfwCreateWindow(screenWidth, screenHeight, "Mandelbrot - Pratica 1", nullptr, nullptr);
    glfwMakeContextCurrent(window);

    glewExperimental = GL_TRUE;
    glewInit();
    glViewport(0, 0, screenWidth, screenHeight);

    Shader myShaders("vShader.vs", "fShader.fs");

    GLfloat vertices[numOfPositions];
    //mandelbrotSet(vertices);

    myShaders.Use();

    GLuint VAO;
    glGenVertexArrays(1, &VAO);
    glBindVertexArray(VAO);
    GLuint VBO;
    glGenBuffers(1, &VBO);
    glBindBuffer(GL_ARRAY_BUFFER, VBO);
    glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);

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

    glBindVertexArray(0);
    // Main Loop
    cout << "AUSDHIAUSDH";
    while (!glfwWindowShouldClose(window)) {
        glClearColor(1.0f, 1.0f, 1.0f, 0.0f);
        glClear(GL_COLOR_BUFFER_BIT);

        glfwPollEvents();

        myShaders.Use();

        glBindVertexArray(VAO);
        glDrawArrays(GL_POINTS, 0, numOfPixels);
        glBindVertexArray(0);

        glfwSwapBuffers(window);
    }

    return 0;
}

void mandelbrotSet(GLfloat vertices[]) {
    double MinRe = -2.0;
    double MaxRe = 1.0;
    double MinIm = -1.2;
    double MaxIm = MinIm + (MaxRe - MinRe) * screenHeight / screenWidth;
    double Re_factor = (MaxRe - MinRe) / (screenWidth - 1);
    double Im_factor = (MaxIm - MinIm) / (screenHeight - 1);
    int MaxIterations = 30;
    int posCount = 0;
    for ( int y = 0; y < screenHeight; ++y ) 
    {
        double c_im = MaxIm - y * Im_factor;
        for ( int x = 0; x < screenWidth; ++x ) 
        {
            double c_re = MinRe + x * Re_factor;
            // Calcula se o pixel se o numero complexo c pertence ao set
            double Z_re = c_re, Z_im = c_im; // Set Z = c
            bool isInside = true;
            for ( int n = 0; n<MaxIterations; ++n )
            {
                double Z_re2 = Z_re*Z_re, Z_im2 = Z_im*Z_im;
                if ( Z_re2 + Z_im2 > 4 )
                {
                    isInside = false;
                    break;
                }
                Z_im = 2 * Z_re*Z_im + c_im;
                Z_re = Z_re2 - Z_im2 + c_re;
            }
            if ( isInside ) 
            {
                vertices[posCount]     = float(x);
                vertices[posCount + 1] = float(y);
                vertices[posCount + 2] = 0.0f;
                vertices[posCount + 3] = 0.0f;
                vertices[posCount + 4] = 0.0f;
                posCount += 5;
            }
            else
            {
                vertices[posCount]     = float(x);
                vertices[posCount + 1] = float(y);
                vertices[posCount + 2] = 1.0f;
                vertices[posCount + 3] = 1.0f;
                vertices[posCount + 4] = 1.0f;
                posCount += 5;
            }
       }
    }
}

Since I am not good at debugging, I tried to put some couts in the code, but nothing shows. Also in debugging mode, the program crashes with the message:

"Unhandled exception at 0x00C21A47 in Mandelbrot - Pratica 1.exe: 0xC00000FD: Stack overflow (parameters: 0x00000000, 0x00DA2000)."

Notice that I commented the function call (mandelbrotSet(vertices)), so I don't think the problem is in the function. EDIT

Also when I comment Shader myShaders("vShader.vs", "fShader.fs"); the problem still persists.

Answer 1

You are experiencing typical stack overflow because the size of array you are trying to allocate on stack is just too big:

const GLint numOfPositions = 5 * 800 * 600;
GLfloat vertices[numOfPositions];

The stack is limited in size (heap too, but much larger [usually]).

And use of debugger would help...

...is there a way to work around that?

Use dynamic allocation on heap (with new or malloc ) or truncate size of array.