|
 |
|
| |
mutable: bitwise vs. logical const
What if you want to create a const
member function, but you’d still like to change some of the data in the
object? This is sometimes referred to as the difference between bitwise
const and logical const
(also sometimes called memberwise
const).
Bitwise const means that every bit in the object is permanent, so a
bit image of the object will never change. Logical const means that,
although the entire object is conceptually constant, there may be changes on a
member-by-member basis. However, if the compiler is told that an object is
const, it will jealously guard that object to ensure bitwise
constness. To effect logical constness, there are two ways to
change a data member from within a const member
function.
The first approach is the historical one
and is called casting away
constness. It is performed
in a rather odd fashion. You take
this (the keyword that
produces the address of the current object) and cast it to a pointer to an
object of the current type. It would seem that this is already
such a pointer. However, inside a const member function it’s
actually a const pointer, so by casting it to an ordinary pointer, you
remove the constness for that operation. Here’s an
example:
//: C08:Castaway.cpp
// "Casting away" constness
class Y {
int i;
public:
Y();
void f() const;
};
Y::Y() { i = 0; }
void Y::f() const {
//! i++; // Error -- const member function
((Y*)this)->i++; // OK: cast away const-ness
// Better: use C++ explicit cast syntax:
(const_cast<Y*>(this))->i++;
}
int main() {
const Y yy;
yy.f(); // Actually changes it!
} ///:~
This approach works and you’ll see
it used in legacy code, but it is not the preferred technique. The problem is
that this lack of constness is hidden away in a member function
definition, and you have no clue from the class interface that the data of the
object is actually being modified unless you have access to the source code (and
you must suspect that constness is being cast away, and look for the
cast). To put everything out in the open, you should use the
mutable keyword in the
class declaration to specify that a particular data member may be changed inside
a const object:
//: C08:Mutable.cpp
// The "mutable" keyword
class Z {
int i;
mutable int j;
public:
Z();
void f() const;
};
Z::Z() : i(0), j(0) {}
void Z::f() const {
//! i++; // Error -- const member function
j++; // OK: mutable
}
int main() {
const Z zz;
zz.f(); // Actually changes it!
} ///:~
This way, the user of the class can see
from the declaration which members are likely to be modified in a const
member function.
|
|
|
