reading the definitions from left to right), the compiler still reads the definitions according to the abovementioned procedure: from right to left. But putting const before what must be constant quickly introduces mismatches between what you intend to write and what the compiler decides you wrote. Consider pointers to pointers: int **ptr; // a pointer to a pointer to ints int const **ptr // a pointer to a pointer to constant int value // (not a pointer to a constant pointer to ints) int *const *ptr // a pointer to a const pointer to int values // (not a constant pointer to a pointer to ints) int **const ptr // a constant pointer to pointers to ints // (ptr, the identifier, being const makes no sense) int const **const ptr // a constant pointer to pointers to constant int values As a final note regarding pointer definitions: always write the pointer symbol (the *) as much as possible to the right. Attaching the pointer symbol to the type is tricky, as it strongly suggests a pointer type, which isn't the case. Here are some examples: int* a; /* write: */ int *a; // a is a pointer to an int int* a, b; // CONFUSING /* write: */ int *a, b; // a is a pointer to an int, // but b is a mere int int* a, *b; // UGLY: both a and b are pointers to ints /* write: */ int *a, *b; Bjarne Stroustrup's FAQ recommends only declaring one variable per line if using the C++ convention, to avoid this issue. The same considerations apply to defining references and rvalue references: int var = 22; int const &refToConst = var; // OK int const& ref2 = var, ref3 = var; // CONFUSING: // ref2 is a reference, but ref3 isn't: // ref3 is a constant int initialized with // var's value int &const constRef = var; // ERROR: as references can't change anyway. // C++: int&& rref = int(5), value = 10; // CONFUSING: // rref is an rvalue reference, but value is // a mere int. /* write: */ int &&rref = int(5), value = 10; More complicated declarations are encountered when using multidimensional arrays and references (or pointers) to pointers. Although it is sometimes argued that such declarations are confusing and error-prone and that they therefore should be avoided or be replaced by higher-level structures,