RULES
AND
RECOMMENDATIONS
Rule 7.8
A pointer or reference parameter should be declared
const
if the function does not change the object bound to it.
Rule 7.9
The copy constructor and copy assignment operator should always have a const reference as parameter.
Rule 7.10
Only use
const char
-pointers to access string literals.
Rule 7.11
A member function that does not change the state of the program should be declared
const
.
Rule 7.12
A member function that gives non-const access to the representation of an object must not be declared
const
.
Rec 7.13
Do not let const member functions change the state of the program.
Rule 5.12
, how to implement copy assignment operator.
Rule 7.7
, return value of copy assignment operator.
Functions often have const reference or const pointer parameters to indicate that an argument is not modified by the function. A good thing with
const
declared parameters is that the compiler will actually give you an error if you modify such a parameter by mistake, thus helping you to avoid bugs in the implementation.
// operator<< does not modify the EmcString parameter
ostream& operator<<(ostream& out, const EmcString& s);
When an argument is passed by value, it is used to initialize a function parameter that will be a copy of the argument. The caller is therefore immune to changes made to that parameter by the called function. If you declare the parameter as
const
in these circumstances you will just be preventing any change to the parameter taking place in the body of the function. This would be of little help, since not being able to change a parameter passed by value only puts unnecessary constraints upon the programmer implementing the function. If a parameter passed by value is declared
const
, the value must be copied to a local variable if the value is to be modified by the function.
By not declaring the parameter
const
, it is possible to use the argument value without first copying the value.
template <class T>
T arraySum(const EmcArray<T>& array,
size_t first,
size_t last)
{
assert(last <= array.length());
T sum = 0;
for( ;first < last; first++)
{
// It is possible to update first since
// it has not been declared const.
sum += array[first];
}
return sum;
}
Two particularly important examples of const parameters are the copy constructors and the copy assignment operators, which should always have a const reference as parameter. In almost all cases it is evident that they should not change the object copied from. Being sloppy in this respect can have drastic consequences, since it will force derived classes and containing classes to also take non-const references as parameters.
If a class inherits another class and provides a copy constructor, this only works if that class has a copy constructor that accepts a const reference parameter. If not, the compiler will report an error, since a const object is passed to a copy constructor taking a non-const parameter. The same problem applies to the case when such a class is used as a data member.
If a class does not allow constant objects to be copied, then it cannot be used in many situations where the programmer expects these properties to hold. It could be when the class is used as a template argument, base class or data member.
There are a few rare exceptions to this rule, such as when the copy is destructive; the new object takes over the state of the old object. This is for example the case if a resource or token, such as a message, is passed from an old object to a new object when the old object is copied.
The following template assumes that the type argument T is copyable.
// Interface
// T is Copyable
template<class T>
class EmcStack
{
public:
// ...
void push(const T& t);
// ...
private:
size_t allocatedM;
size_t topM;
T* repM;
};
// Implementation
// EmcAutoArrayPtr manages arrays of objects
template <class T>
void EmcStack<T>::push(const T& t)
{
if (topM == allocatedM) // allocate more memory
{
size_t newSize = 2 * allocatedM;
EmcAutoArrayPtr<T> newRep(new T[newSize]);
for(size_t i = 0; i < topM; i++)
{
newRep[i] = repM[i];
}
repM = newRep.release();
allocatedM = newSize;
}
// Only works if T is of a type that allows copying
// of constants.
repM[topM] = t;
topM++;
}
Constness is not always as enforced by the language. A very simple example is string literals that are non-const. It is best to always access such strings through const
char
-pointers, so that they cannot be modified. What is not commonly known is that according to the language definition they are of non-const type.
When using a
const char*
instead, the compiler will prevent you from modifying the string literal through the pointer.
Unfortunately this does not guard you from direct assignment to the
pointer itself. It is therefore better to either
const
declare the pointer, or use array notation, since it is not possible to assign to a built-in array.
// NOT RECOMMENDED
char* message1 = "Calling Orson";
// Better
const char* message2 = "Ice Hockey";
// Even better
const char* const message3 = "Terminator";
// Best
const char message4[] = "I like candy";
You should declare all member functions that do not modify the state of the program as
const
. Declaring a member function as
const
has two important implications:
Only const member functions can be called for const objects.
A const member function will not change data members.
It is a common error to forget to
const
declare member functions that should be const. If you forget this, then it will be difficult to pass const references or pointers to objects of that class as arguments to functions. It would also be difficult to use const references or pointers returned from functions.
Please note that it is possible for a const member function to change static data members, global data, as well as the objects that pointer data members are pointing at. It is even possible to modify the object operated upon if a non-const pointer or reference to that object exists.
UselessString
is a class that has not declared any const member functions.
class UselessString
{
public:
UselessString();
UselessString(char* cp);
UselessString(UselessString& u);
~UselessString();
UselessString& operator=(UselessString& u);
char* cStr();
size_t length();
char& operator[](size_t index);
char& at(size_t index);
friend ostream& operator<<(ostream& o,
UselessString& u);
private:
// ...
};
A consequence is that the following code, that you would expect to be legal, will not compile:
void print(const UselessString& s)
{
// Should be possible o print a const object
cout << s << endl; // Will not compile
}
class Silly
{
public:
explicit Silly(int val);
void me(Silly& s) const; // Odd function
private:
int valM;
};
Silly::Silly(int val) : valM(val)
{
// ...
}
The odd thing about the declaration of the function
me()
is that it takes a non-const parameter, which indicates that it might be changed by the function, while the function itself is declared as
const
. If we look at its implementation we can easily see its peculiarity.
void Silly::me(Silly& s) const
{
// valM = 42; // Error: cannot modify valM
s.valM = 42; // OK but odd: s is not const
}
If you call the const member function
me()
with the object operated upon as argument, the object will be modified by the member function call despite the member function's constness.
Silly s(7);
s.me(s); // s.valM == 42, not 7
A member function that gives non-const access to the representation of an object must not be declared
const
, since the object has no control over possible modifications through such pointers or references. The solution is to properly overload member functions with respect to constness.
The following piece of code allows a string to be modified by using the indexing operator to access individual characters.
EmcString name = "John Bauer";
name[0] = 'B'; // OK
The implementation returns a reference to a character that is part of the representation for the string and that can be assigned to. Here, the indexing operator indirectly modifies the object.
The
EmcString
class has overloaded
operator[]
with respect to constness to prevent const objects to be indirectly modified this way.
class EmcString
{
public:
EmcString(const char* cp);
size_t length() const;
// ...
// Non-const version
char& operator[](size_t index);
// Const version
char operator[](size_t index) const;
// ...
private:
size_t lengthM; // Length of string
char* cpM; // A pointer to the characters
};
The string is represented by two data members
cpM
, the character array, and
lengthM
, the length of the string.
The implementation of the indexing operators are straightforward. They just return a reference to the character specified by the index parameter, as long as the index is within bounds.
char& EmcString::operator[](size_t index)
{
assert(index < lengthM);
return cpM[index];
}
The compiler would not complain if this indexing operator is declared
const
, since it is not the pointer
cpM
that is modified, only what it points at. By doing that, one operator member function would have been enough, which would be a benefit for the person maintaining the class. since the fewer member functions the class has, the easier it is to maintain.
From the user's perspective it would be wrong to
const
declare the indexing operator returning a reference, since that would open up the possibility that a constant string could change value. Here, the compiler's interpretation of
const
would not be the same as the programmer's.
const EmcString pioneer = "Roald Amundsen";
// pioneer[0] = 'M'; Should NOT be legal!!
We want to allow each individual character of a
const
declared string to be accessed, but not modified. The correct way to do that is to overload the indexing operator with respect to constness. The const member function does not return a reference so the string cannot be modified through assignment to the return value.
const EmcString s = "hello";
size_t length = s.length();
for (size_t j = 0; j < length; j++)
{
// OK: Read only
cout << "char " << j << ": " << s[j] << endl;
}
A const member function promises, unless cheating, not to change any of the data members of the object. Usually this is not enough as a promise. A const member function should be possible to call any number of times without affecting the state of the complete program. It is therefore also important that a const member function refrains from changing static data members, global data, or other objects which the object has a pointer or reference to. Objects often put some parts of their representation in separate objects and instead have data members that are pointers to these objects. As a complicating factor, it may also be the case that the value of a data member is not part of the state of the object. It could be a value, such as the determinant for a matrix, that was very costly to calculate and therefore cached in an internal data member for efficiency reasons.
If const member functions fulfil their promise not to change the state of the program, then that make them very useful for example as a reliable tool in assertions that checks if the program is in a consistent state. Assertions should be possible to switch off without changing the behavior of the program, which makes it obvious that const member functions must behave as promised.
There are many subtleties involved in this issue. What if there is a log attached to the program, that is used when the program is debugged? Writing to such a log does in some ways affect the state of the program, since it will affect output buffers and the number of open files. The only possible thing to do is to appeal to good engineering judgement.
