我正在创建一个类OpenGLManager，这个类的想法是管理对OpenGL中分配的资源的引用（如Vertex Array Objects和Vertex Buffer Objects）。
所以我想做的是每当我分配一个新资源时，我都会将引用添加到这个类中，每当使用该资源的对象被销毁（析构函数）时，对该资源的引用就会减少。我意识到的一个问题是，在某些情况下，对于一个对象，析构函数被调用两次，这使我的代码中断。 destructor called twice
我基本上创建类似shared_ptr的东西，但是我有处理程序而不是指针。这是代码：
class OpenGLManager
{
public:
static OpenGLManager& getInstance()
{
static OpenGLManager instance;
return instance;
}
// Increment reference counter
void incrementVBO(GLuint vbo);
void incrementVAO(GLuint vao);
void incrementShaderProgram(GLuint program);
// Decrement reference counter
void decrementVAO(GLuint vao);
void decrementVBO(GLuint vbo);
void decrementShaderProgram(GLuint program);
private:
std::unordered_map<GLuint, int> _vbos;
std::unordered_map<GLuint, int> _vaos;
std::unordered_map<GLuint, int> _programs;
OpenGLManager() {};
OpenGLManager(const OpenGLManager&) = delete;
void operator=(OpenGLManager const&) = delete;
};
---------------------------------------------------------------
#include "opengl_manager.h"
using std::vector;
void lh::OpenGLManager::incrementShaderProgram(GLuint program)
{
if (_programs.find(program) == _programs.end())
_programs[program] = 1;
else
_programs[program]++;
}
void lh::OpenGLManager::incrementVAO(GLuint vao)
{
if (_vaos.find(vao) == _vaos.end())
_vaos[vao] = 1;
else
_vaos[vao]++;
}
void lh::OpenGLManager::incrementVBO(GLuint vbo)
{
if (_vbos.find(vbo) == _vbos.end())
_vbos[vbo] = 1;
else
_vbos[vbo]++;
}
void lh::OpenGLManager::decrementVAO(GLuint vao)
{
if (_vaos.count(vao) == 0)
{
std::cerr << "Trying to decrement VAO: " << vao << ". Fatal Error." << std::endl;
exit(EXIT_FAILURE);
}
_vaos[vao]--;
if (_vaos[vao] == 0) // There are no more references
{
auto iter = _vaos.find(vao);
if (iter == _vaos.end())
{
std::cerr << "Trying to remove inexistent hashmap (vao) key." << std::endl;
exit(EXIT_FAILURE);
}
_vaos.erase(iter);
glDeleteVertexArrays(1, &vao);
}
}
void lh::OpenGLManager::decrementVBO(GLuint vbo)
{
if (_vbos.count(vbo) == 0)
{
std::cerr << "Trying to decrement VBO: " << vbo << ". Fatal Error." << std::endl;
exit(EXIT_FAILURE);
}
_vbos[vbo]--;
if (_vbos[vbo] == 0) // There are no more references
{
auto iter = _vbos.find(vbo);
if (iter == _vbos.end())
{
std::cerr << "Trying to remove inexistent hashmap (vbo) key." << std::endl;
exit(EXIT_FAILURE);
}
_vbos.erase(iter);
glDeleteBuffers(1, &vbo);
}
}
void lh::OpenGLManager::decrementShaderProgram(GLuint program)
{
if (_programs.count(program) == 0)
{
std::cerr << "Trying to decrement Program: " << program << ". Fatal Error." << std::endl;
exit(EXIT_FAILURE);
}
_programs[program]--;
if (_programs[program] == 0) // There are no more references
{
auto iter = _programs.find(program);
if (iter == _programs.end())
{
std::cerr << "Trying to remove inexistent hashmap (program) key." << std::endl;
exit(EXIT_FAILURE);
}
_programs.erase(iter);
glDeleteProgram(program);
}
}
这似乎有效，除非我在std::vector上使用push_back添加对象，然后析构函数被调用两次，这会将引用减少2.我怎样才能避免这种情况？或者这只是一个糟糕的设计？
使用OpenGLManager的类的实现
lh::RawModel::RawModel(vector<GLfloat> vertices, vector<GLint> indices, GLenum usage)
: _vao(-1), _indicesCount(indices.size())
{
std::cout << "CREATING MYSELF" << std::endl;
createAndBindVAO();
storeVerticesDataInVBO(0, vertices, 0, usage);
storeVerticesDataInVBO(1, vertices, VERTEX_SIZE * sizeof(GLfloat), usage);
storeIndicesDataInEBO(indices, usage);
unbindVAO();
}
lh::RawModel::~RawModel()
{
// Decrement reference counters for opengl resources
std::cout << "DESTROYING MYSELF" << std::endl;
lh::OpenGLManager::getInstance().decrementVAO(_vao);
lh::OpenGLManager::getInstance().decrementVBO(_vbo);
lh::OpenGLManager::getInstance().decrementVBO(_ebo);
}
const int lh::RawModel::VERTEX_SIZE = 3;
void lh::RawModel::storeIndicesDataInEBO(vector<GLint> indices, GLenum usage)
{
glGenBuffers(1, &_ebo);
lh::OpenGLManager::getInstance().incrementVBO(_ebo);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, _ebo);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, indices.size() * sizeof(GLint), &indices[0], usage);
}
void lh::RawModel::storeVerticesDataInVBO(int iAttribute, vector<GLfloat> data, int offset, GLenum usage)
{
glGenBuffers(1, &_vbo);
lh::OpenGLManager::getInstance().incrementVBO(_vbo);
glBindBuffer(GL_ARRAY_BUFFER, _vbo);
glBufferData(GL_ARRAY_BUFFER, data.size() * sizeof(GLfloat), &data[0], usage);
glVertexAttribPointer(iAttribute, VERTEX_SIZE, GL_FLOAT, GL_FALSE, 2 * (VERTEX_SIZE * sizeof(float)), (GLvoid*)offset);
glEnableVertexAttribArray(iAttribute);
glBindBuffer(GL_ARRAY_BUFFER, 0);
}
void lh::RawModel::createAndBindVAO()
{
glGenVertexArrays(1, &_vao);
glBindVertexArray(_vao);
std::cout << "incrementing vao " << _vao << std::endl;
lh::OpenGLManager::getInstance().incrementVAO(_vao);
}
int lh::RawModel::getNumberOfIndices()
{
return _indicesCount;
}
GLuint lh::RawModel::getVAO()
{
return _vao;
}
void lh::RawModel::unbindVAO()
{
glBindVertexArray(0);
}
中断的呼叫示例：
models_.push_back(lh::RawModel(vertices, indices, GL_STATIC_DRAW));
答案 0 :(得分：2)
这是预期的行为。
遗憾的是，您的设计并不安全。如果你创建一个范围变量，增加它，将它复制到范围外的变量，那么范围变量将被销毁（调用减量），然后，当你最终销毁另一个变量时，它将再次减少，崩溃程序。像这样：
RawModel rawModel;
{
RawModel temp;
temp.increment() //calls increment methods.
rawModel = temp;
} // destructor called once to clean up temp;
// destroy rawModel. destructor called twice to clean up rawModel;
这正是发生的事情，将实例化RawModel然后将其传递给vector，它将你的变量复制到内部，现在你有两个实例来调用析构函数并破坏你的程序。
选项： 1.（推荐）使用shared_ptr。 2.定义复制构造函数和operator =，将内容从一个RawModel复制到另一个并增加计数。
虽然如果您有空闲时间，第二个选项听起来更容易，但请选择选项1，了解shared_ptr，它将在未来的计划中为您提供很多帮助。
1.
shared_ptr<RawModel> rawModel = make_shared(new RawModel);
rawModel->increment() //increment stuff
vector.push_back(rawModel);
//now it'll work.
2.
//additional RawModel methods:
RawModel(const RawModel& rawModel) {
// copies everything and if it is initialized increment
}
const RawModel& operator =(const RawModel& other) {
//same as copy constructur
}
希望这有帮助。
答案 1 :(得分：0)
push_back通过复制来存储对象。不幸的是，你的RawModel只会对其成员进行浅层复制，因此最终会有两个对象引用相同的VBO等。这就是为什么你的减量太多了。
所以你至少需要一个合适的拷贝构造函数和赋值运算符来做正确的事情。如果使用C ++ 11，那么您还需要一个移动构造函数并移动赋值运算符。这是每个C ++开发人员应该学习的Rule of Three / Rule of Five内容。
由于您希望多个对象能够共享所有权，因此您需要做的是：
因此，参考计数应该适当地保持最新。