Question

class SomeClass {
  public:
    void Render() const;

  private:
     mutable Cache m_some_cache;
};

Is the class above const-correct? When can I safely say “This operation doesn’t change the internal state of an instance”?

In the above example SomeClass is something that renders stuff on the screen. It uses a cache (for example OpenGL buffer objects) to allow faster processing for further calls. So the only thing that changes internally is the cache object. I’m asking myself if a cache already belongs to an internal state of a renderer.

The example is very minimal, but in my real application this goes down a road with many classes, i.e. a lot of Render() calls are involved, and most of them do caching only. But some do also load resources through a resource loader — is the assumption here still right that a method may be const even if it queries a resource manager for loading a resource?

Answer 1

Think of it this way. This is perfectly valid:

void Type::print_self () const {
    std::cout << *this << std::endl;
}

You aren’t modifying the object itself, so the use of the const qualifier is perfectly valid. This method is modifying std::cout, but that doesn’t count as far as the constness of Type::print_self() goes.

That said, mutable Cache looks to me to be a contradiction in terms unless you are only using that Cache element for local storage within Render. If you are truly using it as a cache it seems a bit dubious to qualify this element as mutable. Use it as a cache (e.g., across calls to Render rather than within a call to Render) and you have lied to both the compiler and to the user of the class.

Edit
Per the comments made by the OP, the Render method truly is the graphical equivalent of print_self(). The ‘real’ state of the object (presumably not shown for the sake of constructing a minimal working example) presumably isn’t modified by rendering. Designating Render as a const method is the right thing to do. If the Cache data member reason for being is to serve as speed bump that avoids the cost of constructing and destructing it with each call to Render there is nothing wrong with qualifying that Cache member as mutable (which is needed so that Render can remain const).