Mutable Class Members

1class Character {
2public:
3  int GetHealth() const {
4    return Health;
5  }
6
7private:
8  int Health{100};
9};

There are some scenarios where we want certain variables to be changeable (or "mutable") by const methods.

Typically, these are private variables whose value has no noticeable, outward-facing effect. In the following example, we want to keep track of how many times our object's Health value was accessed:

1class Character {
2public:
3  int GetHealth() const {
4    ++HealthRequests;
5    return Health;
6  }
7
8private:
9  int Health{100};
10  int HealthRequests{0};
11};

Naturally, the compiler won't allow this:

1'HealthRequests' cannot be modified because it is being accessed through a const object

We could get around this simply by removing the const specifier, but that's not ideal.

• The function not being marked as const is misleading to any code using our class. Whilst it is changing a data member, the variable it's changing is completely inaccessible and has no visible effect. So, from the perspective of the outside world, the function really should be const
• Removing const specifier has knock-on effects that can reverberate through our code base. For example, any code trying to call GetHealth() on a const reference to this object will now also throw errors.
• The compiler is no longer ensuring this function doesn't change the class in more meaningful ways.

To solve these problems, we have access to the mutable keyword.

Any data member marked as mutable can be freely changed by const methods:

1class Character {
2public:
3  int GetHealth() const {
4    ++HealthRequests;
5    return Health;
6  }
7
8private:
9  int Health{100};
10  mutable int HealthRequests{0};
11};

Of course, to ensure our const specifier remains meaningful, mutable should be used sparingly. It's intended only for variables that, if changed, will not affect the object in any way that outside consumers will notice.

In other words, the meaning of const methods should only have a subtle shift - from "this won't change the object" to "this won't change the object in any way you'll notice"

In this lesson, we explored the mutable keyword, learning how it allows for the modification of class member variables within const member functions.

Main Points Learned

• The const keyword lets us maintain"const correctness" by preventing modification of data members in const methods.
• The mutable keyword enables certain class members to be modified by const methods, useful for variables that don't affect the external state of the object.
• mutable is intended for use cases where modifying a data member does not change the observable behavior of the object, such as logging or caching.
• Proper use of mutable requires careful consideration to ensure it does not compromise the design principles of your class or undermine the value and meaning of const keyword.