In C++, a variable is typically declared as either “const” or “non-const”. A “const” variable is one whose value cannot be changed once it is initialized. On the other hand, a “non-const” variable can be changed at any time during a program’s execution. However, there are situations where you might want a variable to be non-const, but still not allow its value to be changed in certain circumstances. This is where the “mutable” storage class comes in.
What is the “mutable” storage class?
The “mutable” storage class is a C++ keyword that can be applied to any non-static data member of a class. When a data member is declared as “mutable”, it means that it can be modified even if the containing object is declared as “const”. This allows you to modify the value of a member variable within a const function or a const object.
Why use the “mutable” storage class?
The primary reason for using the “mutable” storage class is to allow the modification of a member variable within a const function or a const object. This can be useful in situations where you want to maintain the logical constness of an object, but still need to update a particular member variable.
For example, let’s say you have a class that represents a point in two-dimensional space, with x and y coordinates. You might want to calculate the distance between two points, but you don’t want to modify the points themselves. Here’s an example of how you might implement this:
In this example, the
distanceFrom function is declared as
const, which means that it cannot modify the object on which it is called. However, we still need to access the private member variables
m_y in order to calculate the distance. This is where the
mutable storage class comes in – we can declare
mutable, which makes them modifiable within a
mutable storage class is a powerful feature of C++ that allows you to modify member variables within const functions or const objects. This can be useful in a variety of situations, such as maintaining logical constness while updating a particular variable. However, it should be used judiciously, as it can make your code more difficult to understand and reason about. As with any language feature, it’s important to weigh the benefits against the costs and use it only when appropriate.