Constants simplify code because you only have to look at where the constant is defined to know its value everywhere. Consider this code:
void Fun( vector<int>& v ) {
// …
const size_t len = v.size();
// … 30 more lines … }
When seeing
len 's definition above, you gain instant confidence about
len 's semantics throughout its scope (assuming the code doesn't cast away
const , which it should not do; see below): It's a snapshot of
v 's length at a specific point. Just by looking up one line of code, you know
len 's semantics over its whole scope. Without the
const, len might be later modified, either directly or through an alias. Best of all, the compiler will help you ensure that this truth remains true.
Note that
const is not deep. For example, consider a class
C that has a member of type
X* . In
C objects that are
const , the
X* member is also
const but the
X object that is pointed to is not. (See [Saks99].)Item 43),
mutable is not needed on either the cached information or the unchanging pointer to it.
Yes,
const is "viral"add it in one place, and it wants to propagate throughout your code as you call other functions whose signatures aren't yet const-correct. This is a feature, not a bug, and this quality greatly increases
const 's power even though it was unjustly demeaned in the days when
const wasn't well understood and appreciated. Retrofitting an existing code base to make it const-correct takes effort, but it is worthwhile and likely to uncover latent bugs.
Const-correctness is worthwhile, proven, effective, and highly recommended. Understanding how and where a program's state changes is vital, and
const documents that directly in code where the compiler can help to enforce it. Writing
const appropriately helps you gain a better understanding of your design and makes your code sturdier and safer. If you find it impossible to make a member function
const , you usually gain a better understanding of the ways in which that member function might modify an object's state. You might also understand which data members bridge the gap between physical constness and logical constness, as noted in the following Examples.
Never cast away
const except to call a const-incorrect function, or in rare cases as a workaround for lack of
mutable on older compilers.