C++ 使用默认构造函数调用的Mesh类不适用于OpenGL C++；

我为OpenGL 3.3创建了一个网格类，当我使用非默认构造函数创建该类时，当我创建对象时创建顶点时，该类工作正常。
但是，我现在想要有多个对象，我可以通过将它们放在一个向量中来动态创建它们，所以我必须添加一个默认构造函数，我使用与其他构造函数相同的函数来设置缓冲区数据。。。但它不起作用。据我所知，这不是因为它在向量中，而是因为它与构造函数有关，或者与缓冲区数据稍后创建的事实有关。我真的不太确定

这是我的课。（当我创建一个工作的网格时，我调用带参数的构造函数；当它不工作时，我构建一个没有参数的网格，并调用“changeMesh”函数）

网格.h

#ifndef MESH_H
#define MESH_H

#include <iostream>
#include <vector>
#include <GL/glew.h>
#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include <glm/gtc/type_ptr.hpp>

class mesh
{
    public:
        mesh();
        mesh(std::vector<GLfloat> vertices, std::vector<GLuint> triangles, GLuint shaderProgram);
        ~mesh();
        void changeMesh(std::vector<GLfloat> vertices, std::vector<GLuint> triangles, GLuint shaderProgram);
        void render();
        void Translate(glm::vec3 addVector);
        void Rotate(glm::vec3 rotVector, GLfloat angle);
    protected:
    private:
        GLuint vertexArrayObject, vertexBuffer, elementBuffer, shaderProgram;
        std::vector<GLfloat> vertices;
        std::vector<GLuint> indices;
        glm::mat4 transform;
        void setUpMesh();
        void bindVertices();
};

#endif // MESH_H

\ifndef网格
#定义网格
#包括
#包括
#包括
#包括
#包括
#包括
类网格
{
公众：
网格（）；
网格（std:：矢量顶点、std:：矢量三角形、GLuint着色器程序）；
~mesh（）；
void changeMesh（std:：向量顶点、std:：向量三角形、GLuint着色器程序）；
void render（）；
void Translate（glm:：vec3 addVector）；
空心旋转（glm:：vec3 rotVector，GLfloat angle）；
受保护的：
私人：
GLuint vertexArrayObject、vertexBuffer、elementBuffer、着色器程序；
向量顶点；
std：：向量指数；
glm:：mat4变换；
void setUpMesh（）；
void bindVertices（）；
};
#endif//MESH\u

mesh.cpp

    #include "../include/mesh.h"

mesh::mesh(std::vector<GLfloat> vertices, std::vector<GLuint> indices, GLuint shaderProgram)
{
    this->shaderProgram = shaderProgram;
    this->vertices = vertices;
    this->indices = indices;
    setUpMesh();
}

mesh::mesh(){
    glGenVertexArrays(1, &vertexArrayObject);
    glBindVertexArray(vertexArrayObject);

    glGenBuffers(1, &vertexBuffer);
    glGenBuffers(1, &elementBuffer);
}

mesh::~mesh()
{
    glDeleteBuffers(1, &elementBuffer);
    glDeleteBuffers(1, &vertexBuffer);

    glDeleteVertexArrays(1, &vertexArrayObject);
}

void mesh::changeMesh(std::vector<GLfloat> vertices, std::vector<GLuint> triangles, GLuint shaderProgram){
    this->shaderProgram = shaderProgram;
    this->vertices = vertices;
    this->indices = indices;
    bindVertices();

}

void mesh::setUpMesh(){
    glGenVertexArrays(1, &vertexArrayObject);
    glBindVertexArray(vertexArrayObject);

    glGenBuffers(1, &vertexBuffer);
    glGenBuffers(1, &elementBuffer);

    bindVertices();
    glBindVertexArray(0);

}

void mesh::bindVertices(){
    glBindVertexArray(vertexArrayObject);

    glBindBuffer(GL_ARRAY_BUFFER, vertexBuffer);
    glBufferData(GL_ARRAY_BUFFER, this->vertices.size() * sizeof(GLfloat), this->vertices.data(), GL_STATIC_DRAW);

    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, elementBuffer);
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, this->indices.size() * sizeof(GLuint), this->indices.data(), GL_STATIC_DRAW);


    GLint amountDataPerVert = 5;

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

    glEnableVertexAttribArray(1);
    glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, amountDataPerVert*sizeof(GLfloat), (void*)(3*sizeof(GLfloat)));


    glBindVertexArray(0);

}
void mesh::render(){
    glBindVertexArray(vertexArrayObject);
    glUniformMatrix4fv(glGetUniformLocation(shaderProgram, "transform"), 1, GL_FALSE, glm::value_ptr(transform));

    glDrawElements(GL_TRIANGLES, indices.size(), GL_UNSIGNED_INT, 0);
    glBindVertexArray(0);
}

void mesh::Translate(glm::vec3 addVector){
    transform = glm::translate(transform, addVector);
}

void mesh::Rotate(glm::vec3 rotVector, GLfloat angle){
    transform = glm::rotate(transform, glm::radians(angle), rotVector);
}

#include“./include/mesh.h”
网格：：网格（标准：：向量顶点，标准：：向量索引，GLuint着色器程序）
{
此->着色器程序=着色器程序；
这->顶点=顶点；
这->索引=索引；
setUpMesh（）；
}
网格：：网格（）{
GLGEnVertexArray（1和vertexArrayObject）；
glBindVertexArray（vertexArrayObject）；
glGenBuffers（1和vertexBuffer）；
glGenBuffers（1，&elementBuffer）；
}
网格：：~mesh（）
{
glDeleteBuffers（1和elementBuffer）；
glDeleteBuffers（1和vertexBuffer）；
glDeleteVertexArrays（1和vertexArrayObject）；
}
void mesh:：changeMesh（std:：向量顶点、std:：向量三角形、GLuint着色器程序）{
此->着色器程序=着色器程序；
这->顶点=顶点；
这->索引=索引；
绑定顶点（）；
}
void mesh:：setUpMesh（）{
GLGEnVertexArray（1和vertexArrayObject）；
glBindVertexArray（vertexArrayObject）；
glGenBuffers（1和vertexBuffer）；
glGenBuffers（1，&elementBuffer）；
绑定顶点（）；
glBindVertexArray（0）；
}
void mesh:：bindVertices（）{
glBindVertexArray（vertexArrayObject）；
glBindBuffer（GL_数组_BUFFER，vertexBuffer）；
glBufferData（GL\u数组\u BUFFER，this->vertices.size（）*sizeof（GLfloat），this->vertices.data（），GL\u STATIC\u DRAW）；
glBindBuffer（GL_元素_数组_缓冲区，elementBuffer）；
glBufferData（GL\u ELEMENT\u ARRAY\u BUFFER，this->index.size（）*sizeof（GLuint），this->index.data（），GL\u STATIC\u DRAW）；
闪烁数DataPervert=5；
GlenableVertexAttributeArray（0）；
glvertexattributepointer（0,3，GL_FLOAT，GL_FALSE，amountDataPerVert*sizeof（GLfloat），0）；
GlenableVertexAttributeArray（1）；
glvertexattributepointer（1,2，GL_FLOAT，GL_FALSE，amountDataPerVert*sizeof（GLfloat），（void*）（3*sizeof（GLfloat））；
glBindVertexArray（0）；
}
void mesh:：render（）{
glBindVertexArray（vertexArrayObject）；
glUniformMatrix4fv（glGetUniformLocation（着色器程序，“转换”），1，GL_FALSE，glm:：value_ptr（转换））；
glpaurements（GL_三角形，index.size（），GL_UNSIGNED_INT，0）；
glBindVertexArray（0）；
}
void mesh:：Translate（glm:：vec3 addVector）{
transform=glm:：translate（transform，addVector）；
}
空心网格：：旋转（glm：：vec3旋转向量，GLfloat角度）{
变换=glm:：旋转（变换，glm:：弧度（角度），旋转向量）；
}

虽然您认为问题与将对象存储在向量中无关，但我有一种强烈的感觉，它可能确实存在。你在C++包装中封装OpenGL对象的方式是一个痛苦的处方，你可能发现很多像你之前一样。 典型的问题是由复制和销毁对象时发生的情况组合而成的。C++包装器所拥有的OpenGL对象在析构函数中删除：

mesh::~mesh()
{
    glDeleteBuffers(1, &elementBuffer);
    glDeleteBuffers(1, &vertexBuffer);

    glDeleteVertexArrays(1, &vertexArrayObject);
}

为了说明这个问题，让我们看一个典型的序列。假设您有一个网格对象向量，以及一个向该向量添加新网格的方法（注释点以供以后参考）：

---

为了确保不会意外复制对象，最好为类声明未实现（私有）复制构造函数和赋值运算符。本主题介绍了如何在C++11中做到最好：。

虽然您认为问题与将对象存储在向量中无关，但我强烈感觉它可能确实存在。你在C++包装中封装OpenGL对象的方式是一个痛苦的处方，你可能发现很多像你之前一样。 典型的问题是由复制和销毁对象时发生的情况组合而成的。C++包装器所拥有的OpenGL对象在析构函数中删除：

mesh::~mesh()
{
    glDeleteBuffers(1, &elementBuffer);
    glDeleteBuffers(1, &vertexBuffer);

    glDeleteVertexArrays(1, &vertexArrayObject);
}

为了说明这个问题，让我们看一个典型的序列。假设您有一个网格对象向量，以及一个向该向量添加新网格的方法（注释点以供以后参考）：

---

为了确保不会意外复制对象，最好为类声明未实现（私有）复制构造函数和赋值运算符。本主题介绍如何在C++11中做到最好：。

很可能是因为在

mesh

中声明的任何成员变量都不能默认构造。考虑将成员初始化列表与默认构造函数一起使用。

std::vector<std::shared_ptr<mesh> > m_meshes;

void createMesh(...) {
    std::shared_ptr<mesh> newMesh = std::make_shared<mesh>();
    newMesh->changeMesh(...);
    m_meshes.push_back(newMesh);
}