Home > Blogs > More About mutable

More About mutable

By  Sep 20, 2008

Topics: Programming, C/C++

This post answers a question posted as a comment to Tip #29 use the mutable storage type to hide implementation details."Would using const_cast to achieve the same effect just be another way to skin a cat, or would there be any other important differences that I may be missing?"
I'm answering this question in a separate thread because replies can't use HTML tags.

Seemingly, mutable is just a convenience feature that is meant to rid the programmer from using const_cast so you could say that it’s nothing more than const_cast in disguise. In reality, it isn't. There are two reasons why I think mutable has an added value compared to brute force const_cast.
First, many programmers would avoid const_cast at all costs, which means that they would give up the const in the member function declaration if they didn't have mutable. I haven't checked the statistics but I have the impression that there were fewer const member functions in general in C++ before the advent of mutable.
Second, there's a more sinister aspect of const_cast. This operator is dangerous because it cannot distinguish between truly const objects that are being unconsted and non-const objects that were implicitly converted to const. I'll give an example of both:

#include <iostream>
using namespace std;

void func(const int & num)
{
 const_cast<int>(num&)=6;
}

int main()
{
 int n=0;
 func(n); //#1 non-const object implicitly converted to const
 cout<<n<<endl; //6
 const int m=0; //"real" const
 func(m); //#2 undefined behavior
 cout<<m<<endl; //surprise!
}

In the first func() call, a non-const object is implicitly converted to const, and then its const qualifier is being removed so that a new value can be assigned to it. This const_cast, however ugly, is safe because the object n isn't truly const.

By contrast, in the second func() call the argument is a true const object, which means that the implementation may have stored it in the ROM for example. Using const_cast to modify such an object is undefined, but the programmer const_cast cannot distinguish between these two scenarios. Now assume that the variables n and m are data members of a const object. Declaring these mutable guarantees that undefined behavior such as #2 shall not occur.

Become an InformIT Member

Take advantage of special member promotions, everyday discounts, quick access to saved content, and more! Join Today.

Other Things You Might Like

Xamarin Unleashed

Xamarin Unleashed