Бывают случаи, когда строгое придерживание константности неудобно. Объект может оставаться логически константным ("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
Clocky - это часы-будильник. Идея интересная. Когда его выключаешь, вместо того, чтобы дать тебе спокойно спать дальше, Clocky спрыгивает с тумбочки и начинает удирать от тебя с диким звоном. Ну и ничего не остается, кроме как его ловить, а там уже спать не захочется.
Atom feed