El objeto OpenGL en la clase C++ RAII ya no funciona

c++11

Question

Tengo un objeto OpenGL en una clase de C ++. Como estoy empleando RAII, quiero que el destructor lo elimine. Entonces mi clase se parece a:

class BufferObject
{
private:
GLuint buff_;
public:
BufferObject()
{
glGenBuffers(1, &buff_);
}
~BufferObject()
{
glDeleteBuffers(1, &buff_);
}
//Other members.
};

Esto parece que funciona. Pero cada vez que hago algo de lo siguiente, empiezo a recibir varios errores de OpenGL cuando lo uso:

vector<BufferObject> bufVec;
{
BufferObject some_buffer;
//Initialize some_buffer;
bufVec.push_back(some_buffer);
}
bufVec.back(); //buffer doesn''t work.
BufferObject InitBuffer()
{
BufferObject buff;
//Do stuff with `buff`
return buff;
}
auto buff = InitBuffer(); //Returned buffer doesn''t work.

¿Que esta pasando?

Nota: este es un intento de construir una respuesta canónica a estas preguntas.

Answer 1

Todas esas operaciones copian el objeto C ++. Como su clase no definió un constructor de copia, obtiene el constructor de copia generado por el compilador. Esto simplemente copia a todos los miembros del objeto.

Considere el primer ejemplo:

vector<BufferObject> bufVec;
{
BufferObject some_buffer;
//Initialize some_buffer;
bufVec.push_back(some_buffer);
}
bufVec.back(); //buffer doesn''t work.

Cuando llama a push_back , copia some_buffer en un BufferObject en el vector . Entonces, justo antes de salir de ese ámbito, hay dos objetos BufferObject .

¿Pero qué objeto de tampón OpenGL almacenan? Bueno, almacenan el mismo . Después de todo, en C ++, simplemente copiamos un número entero. Entonces, ambos objetos C ++ almacenan el mismo valor entero.

Cuando some_buffer ese alcance, se destruirá some_buffer . Por lo tanto, llamará a glDeleteBuffers en este objeto OpenGL. Pero el objeto en el vector todavía tendrá su propia copia de ese nombre de objeto OpenGL. Que ha sido destruido .

Entonces ya no puedes usarlo; De ahí los errores.

Lo mismo sucede con su función InitBuffer . buff se destruirá después de que se copia en el valor de retorno, lo que hace que el objeto devuelto no tenga valor.

Todo esto se debe a una violación de la llamada "Regla de 3/5" en C ++. Creó un destructor sin crear copia / mover constructores / operadores de asignación. Eso es malo.

Para resolver esto, sus contenedores de objetos OpenGL deben ser de solo movimiento. Debe eliminar el constructor de copia y el operador de asignación de copia, y proporcionar equivalentes de movimiento que establezcan el objeto movido del objeto 0:

class BufferObject
{
private:
GLuint buff_;
public:
BufferObject()
{
glGenBuffers(1, &buff_);
}
BufferObject(const BufferObject &) = delete;
BufferObject &operator=(const BufferObject &) = delete;
BufferObject(BufferObject &&other) : buff_(other.buff_)
{
other.buff_ = 0;
}
BufferObject &operator=(BufferObject &&other)
{
//ALWAYS check for self-assignment
if(this != &other)
{
Release();
buff_ = other.buff_;
other.buff_ = 0;
}
return *this;
}
~BufferObject() {Release();}
void Release();
{
if(buff_)
glDeleteBuffers(1, &buff_);
}
//Other members.
};

Existen varias otras técnicas para hacer envoltorios RAII de solo movimiento para objetos OpenGL.