Should I declare a method const, when underlying OpenGL state is modified

Question

The following class encapsulates the OpenGL name of a buffer and provides a few methods for changing the state of the buffer:

class BufferObject {
    public:
        explicit BufferObject( GLenum type );
        virtual ~BufferObject();

        // some methods omitted

        void    dataStore( GLsizeiptr size, const GLvoid* data, int usage );
        void*   mapBufferRange( GLintptr offset, GLsizeiptr length, int accessFlag );
        void    unmapBuffer() const;
    private:
        GLuint object_;
};

None of these methods change the state of the BufferObject object, so they could all be declared with const. However, dataStore and mapBufferRange both call OpenGL methods which change the state of the object on the GPU (glBufferData and glMapBufferRange, respectively). I would like to declare them without const to indicate that they are modifying the state on the GPU.

What is the best practise to follow in this situation?

Answer 1

You're right that since they don't modify the actual state of the object itself, you can choose.

While there is no hard-and-fast rule, "use const wherever possible" is definitely not the universal way to go. Refer to functions like std::vector::operator[]—that doesn't change the members of the vector object, but stills provide a non-const version (and a different const version).

One good way of looking at this is: assume you have a BufferObject, and you pass it to a function which takes a const BufferObject&. Will it mess up your expectations (invariants you expect to hold) if that function calls dataStore()? If so, do not mark dataStore() as const.

To address your particular case, I think you're correct and should leave these functions non-const. While they don't modify the physical contents of the C++ object, they do modify the logical state of the entity represented by that C++ object.