Const (computer programming)

Const-correctness is a programming language feature that allows the programmer to indicate when an object can and cannot change by declaring the object const (or non-const). It can be used to improve encapsulation, correctness, and even performance. The best known language with this feature is C++.

When a const object is used, the compiler will do its best to prevent the object from being changed, which allows programmers to utilize a simple form of design contract. The idea of const-ness does not imply that the variable as it is stored in the computer's memory is unwriteable. Rather, const-ness is a compile-time construct that indicates what a programmer may do, not necessarily what he can do. (Of course, if an object resides in a ROM, then it is physically unwriteable regardless of its const-ness from the perspective of the compiler.)

A class method can be declared as const, indicating that calling that method does not change the object. Such const methods can only call other const methods but cannot assign member variables. (In C++, a member variable can be declared as mutable, indicating that a const method can change its value. Mutable member variables can be used for caching and reference counting, where the logical meaning of the object is unchanged, but the object is not physically constant since its bitwise representation may change.)

C/C++ Syntax

For simple types, the const can go on either side of the type (for historical reasons). For instance:

   const char foo = 'a';

is equivalent to

   char const foo = 'a';

Both are chars with constant value. On some implementations, using const on both sides of the type (for instance, const char const) generates a warning but not an error.

Pointers and references

For pointer and reference types, the syntax is slightly more subtle. A pointer object can be declared as a const pointer or a pointer to a const object (or both). A const pointer cannot be reassigned to point to a different object from the one it is initially assigned, but it can be used to modify the object that it points to (called the "pointee"). (Reference variables are thus an alternate syntax for const pointers.) A pointer to a const object, on the other hand, can be reassigned to point to another object of the same type or of a convertible type, but it cannot be used to modify any object. A const pointer to a const object can also be declared and can neither be used to modify the pointee nor be reassigned to point to another object. The following code illustrates these subtleties:

void Foo( int *ptr,
          int const * ptrToConst,
          int *const constPtr,
          int const * const constPtrToConst )
{
       int const i;

       *ptr = 0;  // Ok: modifies the pointee
       ptr  = &i; // Ok: modifies the pointer

       *ptrToConst = 0;  // Error! Cannot modify the pointee
       ptrToConst  = &i; // Ok: modifies the pointer

       *constPtr = 0;  // Ok: modifies the pointee
       constPtr  = &i; // Error! Cannot modify the pointer

       *constPtrToConst = 0;  // Error! Cannot modify the pointee
       constPtrToConst  = &i; // Error! Cannot modify the pointer
}

To render the syntax for pointers more comprehensible, a rule of thumb is to read the declaration from right to left. Thus, everything before the star can be identified as the pointee type and everything to the left are the pointer properties. (For instance, in our example above, constPtrToConst can be read as a const pointer that refers to a const int.)

References follow similar rules. A declaration to a const reference is permitted for the sake of templates but is technically redundant since references can never be made to point to another object:

int i = 42;
int const & refToConst = i; // Ok
int & const constRef   = i; // Nonsensical; may compile, but may not

Even more complicated declarations can result when using multidimensional arrays and references (or pointers) to pointers. Generally speaking, these should be avoided or replaced with higher level structures because they are confusing and prone to error.

Loop-holes to const-correctness

There are two loop-holes to pure const-correctness in C and C++. They exist primarily for compatibility with existing code.

The first, which applies only to C++, is the use of const_cast, which allows the programmer to strip the const qualifier, making any object modifiable. The necessity of stripping the qualifier arises when using existing code and libraries that cannot be modified but which are not const-correct. For instance, consider this code:

// Prototype for a function which we cannot change but which 
// we know does not modify the pointee passed in.
void LibraryFunc( int * ptr, int size );

void CallLibraryFunc( int const * const ptr, int const size )
{
    LibraryFunc( ptr, size ); // Error! Drops const qualifier

    int *const nonConstPtr = const_cast<int*>( ptr ); // Strip qualifier
    LibraryFunc( nonConstPtr, size );  // Ok
}

The other loop-hole applies both to C and C++. Specifically, the languages dictate that member pointers and references are "shallow" with respect to the const-ness of their owners — that is, a containing object that is const has all const members except that member pointees (and referees) are still mutable. To illustrate, consider this code:

struct S 
{ 
   int   val;
   int * ptr;
};

void Bar( S const s )
{
   int i  = 42;
   s.val  = i;  // Error: s is const, so val is a const int
   s.ptr  = &i; // Error: s is const, so ptr is a const pointer
   *s.ptr = 0;  // Ok: the data pointed to by ptr is always mutable,
                //     even though this is usually not desirable
}

Although the structure s passed to Bar() is constant, which makes all of its members constant, the pointee accessible through s.ptr is still modifiable, though this is not generally desirable from the standpoint of const-correctness because s may solely own the pointee. For this reason, some have argued that the default for member pointers and references should be "deep" const-ness, which could be overridden by a mutable qualifier when the pointee is not owned by the container, but this strategy would create compatibility issues with existing code. Thus, for historical reasons, this loop-hole remains open in C and C++.

volatile

The other qualifier in C and C++, volatile, indicates that an object may be changed by another thread at unexpected times and so must be re-read from memory every time it is accessed. It can be used in exactly the same manner as const in declarations of variables, pointers, references, and member functions, but such use has little semantic value, except in the case of variables. The const_cast keyword can also be used to strip the volatile qualifier.