Имеет ли ключевое слово mutable какую-либо цель, кроме разрешения изменения переменной с помощью константной функции?

Ваше использование с boost :: mutex - это именно то, для чего предназначено это ключевое слово. Другое использование - внутреннее кэширование результатов для ускорения доступа.

По сути, «изменчивый» применяется к любому атрибуту класса, который не влияет на внешне видимое состояние объекта.

В примере кода вашего вопроса mutable может быть неприемлемым, если значение done_ влияет на внешнее состояние, это зависит от того, что находится в ...; часть.

Mutable предназначен для обозначения определенного атрибута как изменяемого из методов const. Это его единственная цель. Тщательно подумайте, прежде чем использовать его, потому что ваш код, вероятно, будет чище и читабельнее, если вы измените дизайн, а не используете mutable.

http://www.highprogrammer.com/alan/rants/mutable.html

So if the above madness isn't what mutable is for, what is it for? Here's the subtle case: mutable is for the case where an object is logically constant, but in practice needs to change. These cases are few and far between, but they exist.

Примеры, которые приводит автор, включают кеширование и временные отладочные переменные.

В некоторых случаях (например, плохо спроектированные итераторы) классу необходимо вести счетчик или другое случайное значение, которое на самом деле не влияет на основное «состояние» класса. Чаще всего я вижу, что используется изменяемый. Без mutable вы были бы вынуждены пожертвовать всей константностью вашего дизайна.

Мне тоже большую часть времени кажется хакерским. Полезно в очень немногих ситуациях.

Это полезно в ситуациях, когда у вас есть скрытое внутреннее состояние, такое как кеш. Например:

class HashTable
{
...
public:
    string lookup(string key) const
    {
        if (key == lastKey)
            return lastValue;

        string value = lookupInternal(key);

        lastKey = key;
        lastValue = value;

        return value;
    }

private:
    mutable string lastKey, lastValue;
};

И тогда вы можете сделать так, чтобы объект const HashTable по-прежнему использовал свой метод lookup(), который изменяет внутренний кеш.

Это позволяет различать поразрядную константу и логическую константу. Логическая константа - это когда объект не изменяется так, как это видно через общедоступный интерфейс, как в вашем примере блокировки. Другой пример - класс, который вычисляет значение при первом запросе и кэширует результат.

Поскольку C++ 11 mutable может использоваться в лямбда-выражении, чтобы обозначить, что вещи, захваченные по значению, можно изменять (по умолчанию это не так):

int x = 0;
auto f1 = [=]() mutable {x = 42;};  // OK
auto f2 = [=]()         {x = 42;};  // Error: a by-value capture cannot be modified in a non-mutable lambda

mutable в основном используется в деталях реализации класса. Пользователю класса не нужно знать об этом, поэтому метод, который, по его мнению, «должен» быть const, может быть. Ваш пример с изменяемым мьютексом - хороший канонический пример.

Ну да, вот что он делает. Я использую его для членов, которые изменяются методами, которые не изменяют логически состояние класса - например, для ускорения поиска путем реализации кеша:

class CIniWrapper
{
public:
   CIniWrapper(LPCTSTR szIniFile);

   // non-const: logically modifies the state of the object
   void SetValue(LPCTSTR szName, LPCTSTR szValue);

   // const: does not logically change the object
   LPCTSTR GetValue(LPCTSTR szName, LPCTSTR szDefaultValue) const;

   // ...

private:
   // cache, avoids going to disk when a named value is retrieved multiple times
   // does not logically change the public interface, so declared mutable
   // so that it can be used by the const GetValue() method
   mutable std::map<string, string> m_mapNameToValue;
};

Теперь вы должны использовать это с осторожностью - проблемы параллелизма являются большой проблемой, поскольку вызывающий может предположить, что они являются потокобезопасными, если только используют методы const. И, конечно же, изменение данных mutable не должно существенно изменить поведение объекта, что могло бы быть нарушено приведенным мной примером, если, например, ожидалось, что изменения, записанные на диск, будут немедленно видимы для пользователя. приложение.

Его использование не является хакерским, хотя, как и многие другие вещи в C++, изменяемый может - это хитрость для ленивого программиста, который не хочет возвращаться полностью и отмечать то, что не должно быть константным, как неконстантное.

mutable действительно существует, как вы предполагаете, чтобы позволить изменять данные в другой постоянной функции.

Предполагается, что у вас может быть функция, которая «ничего не делает» для внутреннего состояния объекта, и поэтому вы помечаете функцию const, но вам действительно может потребоваться изменить состояние некоторых объектов таким образом, чтобы это не влияло на его правильный функционал.

Ключевое слово может действовать как подсказка для компилятора - теоретический компилятор может поместить в память постоянный объект (например, глобальный), который был помечен как доступный только для чтения. Наличие mutable намекает, что этого делать не следует.

Вот несколько веских причин для объявления и использования изменяемых данных:

• Безопасность потоков. Объявление mutable boost::mutex совершенно разумно.
• Статистика. Подсчет количества вызовов функции с учетом некоторых или всех ее аргументов.
• Воспоминание. Вычисление дорогостоящего ответа с последующим сохранением его для использования в будущем, а не повторное вычисление.

Ключевое слово mutable - это способ пробить завесу const, которую вы накрываете своими объектами. Если у вас есть константная ссылка или указатель на объект, вы не можете каким-либо образом изменить этот объект Кроме, когда и как он помечен как mutable.

С помощью ссылки или указателя const вы ограничены:

• доступ только для чтения для любых видимых элементов данных
• разрешение на вызов только тех методов, которые помечены как const.

Исключение mutable позволяет теперь записывать или устанавливать элементы данных, помеченные mutable. Это единственное внешне видимое отличие.

Внутренне те методы const, которые вам видны, также могут записывать элементы данных, помеченные mutable. По сути, покровная вуаль пронизана полностью. Это полностью зависит от разработчика API, чтобы убедиться, что mutable не разрушает концепцию const и используется только в полезных особых случаях. Ключевое слово mutable помогает, потому что оно четко отмечает элементы данных, которые подпадают под эти особые случаи.

На практике вы можете одержимо использовать const во всей кодовой базе (вы, по сути, хотите «заразить» свою кодовую базу «болезнью» const). В этом мире указатели и ссылки - это const с очень небольшим количеством исключений, что дает код, который легче рассуждать и понимать. Для интересного отступления поищите "ссылочная прозрачность".

Без ключевого слова mutable вы в конечном итоге будете вынуждены использовать const_cast для обработки различных полезных специальных случаев, которые он позволяет (кэширование, подсчет ссылок, данные отладки и т. д.). К сожалению, const_cast значительно более разрушителен, чем mutable, потому что он заставляет API клиент разрушать защиту const объектов, которые он использует. Вдобавок это вызывает повсеместное разрушение const: указатель или ссылка в const_cast разрешает неограниченный доступ для записи и вызова методов к видимым элементам. Напротив, mutable требует, чтобы разработчик API осуществлял детальный контроль исключений const, и обычно эти исключения скрыты в методах const, работающих с частными данными.

(N.B. Я несколько раз ссылаюсь на данные и метод видимость. Я говорю о членах, помеченных как открытые, частные или защищенные, что представляет собой совершенно другой тип защиты объекта, обсуждаемый здесь.)

Классический пример (как упоминалось в других ответах) и единственная ситуация, в которой я видел ключевое слово mutable, используемое до сих пор, - это кеширование результата сложного метода Get, где кеш реализован как член данных класса, а не как статическая переменная в методе (по причинам разделения между несколькими функциями или простой чистоты).

В общем, альтернативой использованию ключевого слова mutable обычно является статическая переменная в методе или трюк const_cast.

Другое подробное объяснение находится в здесь.

Mutable используется, когда у вас есть переменная внутри класса, которая используется только внутри этого класса, чтобы сигнализировать о таких вещах, как, например, мьютекс или блокировка. Эта переменная не меняет поведения класса, но необходима для реализации потоковой безопасности самого класса. Таким образом, без «изменяемого» вы не сможете иметь «константные» функции, потому что эту переменную нужно будет изменить во всех функциях, доступных внешнему миру. Поэтому mutable был введен для того, чтобы сделать переменную-член доступной для записи даже для константной функции.

The mutable specified informs both the compiler and the reader that it is safe and expected that a member variable may be modified within a const member function.

Используйте "изменяемый", когда для вещей, которые ЛОГИЧЕСКИ не имеют состояния для пользователя (и, следовательно, должны иметь "константные" геттеры в API общедоступных классов), но НЕ не имеют состояния в базовой РЕАЛИЗАЦИИ (код в вашем .cpp).

Случаи, которые я использую чаще всего, - это ленивая инициализация членов "простых старых данных" без состояния. А именно, он идеален в узких случаях, когда создание таких элементов (процессор) или переноска (память) требует больших затрат, и многие пользователи объекта никогда не будут их запрашивать. В этой ситуации вам нужно ленивое построение на серверной части для повышения производительности, поскольку 90% построенных объектов вообще не нуждаются в их построении, но вам все равно необходимо предоставить правильный API без сохранения состояния для публичного использования.

Изменяемый может быть удобен, когда вы переопределяете виртуальную функцию const и хотите изменить переменную члена дочернего класса в этой функции. В большинстве случаев вы не захотите изменять интерфейс базового класса, поэтому вам придется использовать собственные изменяемые переменные-члены.

Само ключевое слово mutable на самом деле является зарезервированным. Часто оно используется для изменения значения постоянной переменной. Если вы хотите иметь несколько значений константы, используйте ключевое слово mutable.

//Prototype 
class tag_name{
                :
                :
                mutable var_name;
                :
                :
               };   

Ключевое слово mutable очень полезно при создании заглушек для целей тестирования классов. Вы можете заглушить константную функцию и по-прежнему иметь возможность увеличивать (изменяемые) счетчики или любую другую тестовую функцию, которую вы добавили в свою заглушку. Это сохраняет неизменным интерфейс заглушенного класса.

Mutable изменяет значение const с поразрядной константы на логическую константу для класса.

Это означает, что классы с изменяемыми членами больше не являются побитовыми константами и больше не будут отображаться в разделах исполняемого файла только для чтения.

Кроме того, он изменяет проверку типов, позволяя функциям-членам const изменять изменяемые элементы без использования const_cast.

class Logical {
    mutable int var;

public:
    Logical(): var(0) {}
    void set(int x) const { var = x; }
};

class Bitwise {
    int var;

public:
    Bitwise(): var(0) {}
    void set(int x) const {
        const_cast<Bitwise*>(this)->var = x;
    }
};

const Logical logical; // Not put in read-only.
const Bitwise bitwise; // Likely put in read-only.

int main(void)
{
    logical.set(5); // Well defined.
    bitwise.set(5); // Undefined.
}

Дополнительные сведения см. В других ответах, но я хотел подчеркнуть, что это не только для обеспечения безопасности типов и влияет на скомпилированный результат.

Один из лучших примеров использования mutable - это глубокая копия. в конструкторе копирования мы отправляем const &obj в качестве аргумента. Таким образом, новый созданный объект будет постоянного типа. Если мы хотим изменить (в основном мы не будем менять, в редких случаях мы можем изменить) члены в этом вновь созданном объекте const, нам нужно объявить его как mutable.

Класс хранения mutable может использоваться только для нестатических неконстантных членов данных класса. Изменяемый член данных класса может быть изменен, даже если он является частью объекта, объявленного как const.

class Test
{
public:
    Test(): x(1), y(1) {};
    mutable int x;
    int y;
};

int main()
{
    const Test object;
    object.x = 123;
    //object.y = 123;
    /* 
    * The above line if uncommented, will create compilation error.
    */   

    cout<< "X:"<< object.x << ", Y:" << object.y;
    return 0;
}

Output:-
X:123, Y:1

В приведенном выше примере мы можем изменить значение переменной-члена x, хотя она является частью объекта, объявленного как const. Это потому, что переменная x объявлена ​​изменяемой. Но если вы попытаетесь изменить значение переменной-члена y, компилятор выдаст ошибку.