引用计数器和析构函数被调用两次
Posted
技术标签:
【中文标题】引用计数器和析构函数被调用两次【英文标题】：Reference Counter and destructor being called twice 【发布时间】：2015-07-20 22:33:27 【问题描述】：我正在创建一个类 OpenGLManager，这个类的想法是管理对 OpenGL 中分配的资源的引用（如顶点数组对象和顶点缓冲区对象）。
所以我想做的是每当我分配一个新资源时，我都会将引用添加到这个类中，并且每当使用这个资源的对象被销毁（析构函数）时，对这个资源的引用就会减少。我意识到的一个问题是，在某些情况下，为一个对象调用了两次析构函数，这使我的代码中断。 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));
【问题讨论】：
向我们展示一个实际使用递增和递减例程的类。很可能您需要根据三规则问题对其复制构造函数和赋值运算符做一些事情。 好的，已经更新了帖子 你应该看到这个question关于使用 OpenGL 的 RAII。 【参考方案1】：这是预期的行为。
很遗憾，您的设计并不安全。如果您创建一个作用域变量，将其递增，将其复制到作用域外的变量，则作用域变量将被销毁（调用减量），然后，当您最终销毁另一个变量时，它将再次减量，使程序。像这样的：
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，然后将其传递给向量，向量将变量复制到其中，现在您有两个实例来调用析构函数并破坏您的程序。
选项： 1.（推荐）使用shared_ptr。 2. 定义复制构造函数和操作符 =，将内容从一个 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
希望这会有所帮助。
【讨论】：
【参考方案2】：push_back 通过复制对象来存储它。不幸的是，您的 RawModel 只会浅复制其成员，因此最终会有两个对象引用相同的 VBO 等。这就是为什么你的减量发生得太多了。
因此，您至少需要一个合适的复制构造函数和赋值运算符来做正确的事情。如果使用 C++11，那么您还需要一个移动构造函数和移动赋值运算符。这是每个 C++ 开发人员都应该学习的Rule of Three / Rule of Five 东西。
既然您希望多个对象能够共享所有权，那么您需要做的是：
实现复制/赋值运算符，以便它们在执行复制时增加引用计数。 实现移动操作符，以便它们清除要移动数据的对象的成员。因此，引用计数应该适当地保持最新。
【讨论】：
以上是关于引用计数器和析构函数被调用两次的主要内容，如果未能解决你的问题，请参考以下文章