How Can I Safely Manage OpenGL Objects within C RAII Classes?

OpenGL Objects in C RAII Classes: Pitfalls and Solutions

In C RAII classes, members are automatically released when the object goes out of scope to ensure resource deallocation. However, when dealing with OpenGL objects in such classes, unintended consequences can arise.

Consider the following code:

class BufferObject
{
private:
  GLuint buff_;

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

This class manages an OpenGL buffer object, which should be deleted in the destructor. However, unexpected errors occur when attempting to copy or move-construct these objects.

The issue stems from the lack of explicit copy or move constructors/assignment operators. The compiler-generated copy constructor simply copies the member variables, leading to two objects sharing the same OpenGL buffer object. When one object is destroyed, the other becomes invalid, resulting in errors.

Similarly, the InitBuffer function:

BufferObject InitBuffer()
{
  BufferObject buff;
  // Do stuff with `buff`
  return buff;
}

also fails because buff is destroyed after being copied into the return value.

To resolve these pitfalls, move-only types should be employed. In C , this means deleting the copy constructor and copy assignment operator, while providing move equivalents that transfer ownership:

class BufferObject
{
private:
  GLuint buff_;

public:
  BufferObject() { glGenBuffers(1, &buff_); }
  BufferObject(const BufferObject&) = delete; // no copy constructor
  BufferObject& operator=(const BufferObject&) = delete; // no copy assignment

  BufferObject(BufferObject&& other) : buff_(other.buff_) { other.buff_ = 0; }
  BufferObject& operator=(BufferObject&& other)
  {
    if(this != &other)
    {
      Release(); // release current resource
      buff_ = other.buff_;
      other.buff_ = 0;
    }
    return *this;
  }
  ~BufferObject() { Release(); }
  void Release() { if(buff_) glDeleteBuffers(1, &buff_); }
  // Other members
};

With these changes, copying and moving BufferObject instances becomes safe, and OpenGL resources are managed correctly within the RAII pattern.

The above is the detailed content of How Can I Safely Manage OpenGL Objects within C RAII Classes?. For more information, please follow other related articles on the PHP Chinese website!