C++ destructor weird behavoiur - c++

Question

I have a model class which contains the buffers for the model to draw, it's implementation looks like this:
Model::Model(std::vector<Vertex> vertices, std::vector<short> indices)
{
mVertices = vertices;
mIndices = indices;
mMatrix = glm::mat4(1.0f);
mIsTextured = false;
Initialize();
}
Model::~Model()
{
glDeleteBuffers(1, &mVertexBuffer);
glDeleteBuffers(1, &mIndiceBuffer);
}
void Model::Initialize()
{
glGenBuffers(1, &mVertexBuffer);
glBindBuffer(GL_ARRAY_BUFFER, mVertexBuffer);
glBufferData(GL_ARRAY_BUFFER, sizeof(Vertex)*mVertices.size(), &mVertices[0], GL_STATIC_DRAW);
glGenBuffers(1, &mIndiceBuffer);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, mIndiceBuffer);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(short)*mIndices.size(), &mIndices[0], GL_STATIC_DRAW);
}
Now I've encountered a very weird problem with the destructor, I use this class like this:
Renderer *renderer = new Renderer();
Model m = parseSKNFromFile("model.skn");
m.ApplyTexture(textureID);
while (!glfwWindowShouldClose(window))
{
update();
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
renderer->RenderModel(&m);
glfwSwapBuffers(window);
glfwPollEvents();
}
Using the Model class this way triggers a runtime Access Violation Reading Location error, but if I comment the glDeleteBuffers call inside the constructor everything working find.
It looks like somehow those delete functions called out of nowhere and I cant figure out how and why.
Here's the RenderModel function too:
mShader.bind();
glm::mat4 MVP = mProjection * glm::lookAt(glm::vec3(0, 100, 200), glm::vec3(0, 100, 0), glm::vec3(0, 1, 0)) * model->GetMatrix();
glUniformMatrix4fv(mShader.getUniformLocation("MVP") , 1, GL_FALSE, &MVP[0][0]);
if (model->IsTextured())
{
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, model->GetTexture());
glUniform1i(model->GetTexture(), 0);
}
glEnableVertexAttribArray(0);
glEnableVertexAttribArray(1);
glEnableVertexAttribArray(2);
glEnableVertexAttribArray(3);
glEnableVertexAttribArray(4);
glBindBuffer(GL_ARRAY_BUFFER, model->GetVertexBuffer());
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void*)0); //float position[3]
glVertexAttribPointer(1, 1, GL_INT, GL_FALSE, sizeof(Vertex), (void*)12); //char boneIndex[4]
glVertexAttribPointer(2, 4, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void*)16); //float weights[4]
glVertexAttribPointer(3, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void*)32); //float normals[3]
glVertexAttribPointer(4, 2, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void*)44); //float textureCords[2]
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, model->GetIndiceBuffer());
glDrawElements(GL_TRIANGLES, model->GetIndiceSize(), GL_UNSIGNED_SHORT, (void*)0);
glDisableVertexAttribArray(0);
glDisableVertexAttribArray(1);
glDisableVertexAttribArray(2);
glDisableVertexAttribArray(3);
glDisableVertexAttribArray(4);

Answer 1

An assumption: You do not have (can not have) a proper copy constructor/assignment operator.
Hence:
private;
Model(const Model&); // No copy
Model& operator = (const Model&); // No copy

Answer 2

Since you are creating an inline object of Model it will be destroyed automatically when it goes out of scope and that scope is at the end of the function where you instantiate a Renderer.
I would suggest changing the Model to a heap allocated object and destroy it manually before you free the Renderer and before you destroy the window.
Model* m = parseSKNFromFile( "model.skn" );
There are some other suggestions that I would make like taking the arrays of indices and vertices as const references in the constructor of the Model. Also I don't think it is a great idea to call gl commands from the destructor of the object, it would be better to separate that type of functionality to separate functions in the Model as well as not initialize the OpenGL buffers in the constructor either. The reasons for that is in case you want to separate object allocation from the renderer initialization so that you can be loading them on a separate thread from the rendering thread.