mutable и const_cast

Бывают случаи, когда строгое придерживание константности неудобно. Объект может оставаться логически константным ("logically const"), но при этом его физическая константность ("physically const") может быть нарушена. Пример: в неком классе на основании данных класса по очень сложному и долгому алгоритму считается некая величина. Хорошо бы эту величину закэшировать.

class CFoo
{
  int cachedValue;
  bool bCached;
  ...
public:
  int calculate() const
  {
    //долгое вычисление
    cachedValue = ...; //ошибка
    //нельзя делать присвоение данным класса в константной функции
  }
  ...
};

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

class CFoo
{
  mutable int cachedValue;
  mutable bool bCached;
  ...
public:
  int calculate() const
  {
    if(bCached) return cachedValue;
    //долгое вычисление
    cachedValue = ...; //все в порядке
    bCached = true;
  }
  ...
};

Подобное кэширование данных - это классический пример использования mutable.
mutable означает, что спецификатор const, примененный к классу, следует игнорировать. По стандарту только данные класса могут быть mutable.
Признак правильного использования mutable: если при доступе к данным через интерфейс класса все выглядит так, будто в классе ничего не менялось, то можно использовать mutable.
Еще один классический пример использования mutable - это синхронизация доступа к данным. Допустим, у нас есть класс, содержащий переменную, хранящую некоторое значение (data), и объект, отвечающий за синхронизацию доступа в многопоточных приложениях (sync_obj). Также есть две функции, отвечающие за доступ к данным: set_data и get_data. Функция get_data должна быть константной, она же не меняет данные класса, но как ей тогда залочить доступ к данным? Объявить sync_obj как mutable.

class mutable_test
{
  int     data;
  mutable sync  sync_obj;
public:

  void set_data (int i)
  {
      sync_obj.lock ();
      data = i;
      sync_obj.unlock ();
  }

  int get_data () const
  {
      sync_obj.lock ();
      int i = data;
      sync_obj.unlock ();
      return i;
  }
};

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

int i;
const int * pi = &i;
// *pi имеет тип const int,
// но pi указывает на int, который константным не является
int* j = const_cast<int *> (pi);

Если же попробовать убрать const с объекта, который на самом деле const, результатом будет undefined behaviour.

struct Foo { int val; };

int main()
{
  const Foo obj = { 1 };
  const_cast<Foo *>(&obj)->val = 3;  // undefined behaviour
  return obj.val;
}

Ссылки по теме:
comp.lang.c++.moderated "usefulness of const_cast"
comp.lang.c++.moderated "legitimate use of const_cast"
comp.lang.c++.moderated "mutable: why it's in the language"


Technorati tag: cpp