When have you used C++ 'mutable' keyword? [closed]

Answer 1

I've used mutable in case of object caching results calculated from internal members:

class Transformation
{
    private:
        vec3 translation;
        vec3 scale;
        vec4 rotation;
        mutable mat4 transformation;
        mutable bool changed;
    public:
        Node()
        {
            [...]
            changed = false;
        }
        void set_translation(vec3 _translation)
        {
            translation = _translation;
            changed = true;
        }
        void set_scale(...) ...


        mat4 get_transformation() const
        {
            if(changed)
            {
                 // transformation and changed need to be mutable here
                 transformation = f(translation, scale, rotation); // This take a long time...
                 changed = false;
            }
            return transformation;
        }
};

void apply_tranformation(const Transformation* transfo)
{
    apply(transfo->get_transformation());
}

Answer 2

Google code search reveals a number of uses. For example, in an implementation of XTR cryptography, mutable members are used so that methods can return a reference to a result (preventing copies from being made).

For another example, Webkit uses it to lazily initialize member data (m_lineHeight).

Answer 3

It can also be used if inside a getter method (that is usually const), you need to update the stored returned value. As an example, suppose that you have an specific linked-list implementation. For performance issues, you keep the last calculated length of the list, but while returning the length, if the list has been modified, you compute it again, otherwise, you return the last cached value.

class MyLinkedList
{
public:
  long getLength() const
  {
    if (lengthIsModified())
    {
      mLength = ...; // do the computation here
    }
    return mLength;
  }
private:
  mutable long mLength;
};

Warning: It is not that easy to always keep mLength up-to-date because of some specific operations (like merging) in the list.

Answer 4

Occasionally I use it to mark a mutex or other thread synchronisation primitive as being mutable so that accessors/query methods, which are typically marked const can still lock the mutex.

It's also sometimes useful when you need to instrument your code for debugging or testing purposes, because instrumentation often needs to modify auxiliary data from inside query methods.

Answer 5

mutable keyword allows you to modify a variable inside a const context

e.g:

class Person {
private:
      mutable int age;

public:
    Person(int age) : age(age)  {

    }
    void setAge(int age) const {
        Person::age = age;
    }

    int getAge() const {
        return Person::age;
    }
};

int main() {

    Person person(23);
    std::cout << "Person age " << person.getAge() << std::endl;
    person.setAge(24);
    std::cout << "Person modified age " << person.getAge() << std::endl;
    return 0;
}