Constructors and Member Initialization

A user-defined arithmetic type such as a complex number class is built from member functions. Some of those functions only read the object's data, while others change it. C++ lets you record that difference in the declaration itself, so that a reader of the class, and the compiler, can tell in advance what a call is allowed to do to the object it is called on.

Before reading the rules, run the program in your head and keep track of which member functions are called on the object. The setter changes re, and the getter only reads it. The rest of this article explains how the declaration records that difference and what happens when you ask the compiler to allow a change on an object that was declared not to change.

Follow one complex value through two steps. The object is created with the real part 1.0 and the imaginary part 3.0. Then the real part is replaced with 5.0 through the setter. The diagram shows what each member holds after each step. The imaginary part never changes, because no line in this sequence writes to it.

The word const placed after the parameter list of a member function is a promise made to the compiler and to other programmers. It states that the function will not modify the object it is called on. In the complex class, the two getters real() and imag() carry this promise. Each one simply returns a stored value, and nothing in its body writes to re or im.

Reading the declaration double real() const tells you three things before you see the body: the function returns a double, it takes no arguments, and it leaves the object unchanged. The const marking sits at the end of the signature, after the parentheses, which is where the promise about the object is recorded. The setters real(double) and imag(double) have no such marking, so the declaration itself tells you they are allowed to change the object.

A useful way to check whether a call is legal is to ask two questions in order. First, is the object const? Second, is the member function marked const? If the object is not const, any member function may be called on it. If the object is const, only a member function marked const may be called.

Not every operation on a complex number needs to live inside the class body. Many useful operations do not need direct access to the internal representation, so they can be defined separately from the class definition. The class itself keeps the operations that do need the stored parts.

The compound assignment operators are the example of member functions that do need that access. operator+= adds the other value's parts into re and im and then returns *this. Because it changes the object by design, it is not marked const. This is the same distinction as before: a function that must change the object goes unmarked, and a function that only reads it carries the const promise.

Every object of a class holds data, and that data has to start somewhere. In a complex number class that stores a real part and an imaginary part, each stored part needs a value before any arithmetic can happen. The constructor is the place where that starting value is arranged, and the arrangement matters for correctness because later code assumes the parts already hold meaningful numbers.

Read the three constructors as three entries in the same list. This is the feature called overloading: one name, several constructors, with the compiler choosing among them by the arguments present. Constructors can be overloaded to accept different numbers and types of arguments, and the three entries above are a concrete instance of that rule. The one-argument constructor shown here is an illustration added for this article; the source itself shows the empty and two-argument forms as the complex class's constructors.

The compiler selects a constructor by looking at the argument list in the declaration. An empty list selects the constructor that takes no arguments. A single double selects the one-argument form. Two doubles select the two-argument form. The declaration's parentheses, and the number and type of what is inside them, determine the match.

The source makes a specific claim about the default constructor: by defining one, you eliminate the possibility of uninitialized variables of that type. The benefit is a guarantee about the class as a whole. Any variable of type complex that is declared without arguments starts with a defined value of {0,0}, so code that reads its real and imaginary parts does not depend on luck.

When a value from a constructed object is not what you expected, the fastest route is to trace which constructor ran and what it assigned. Work this case the way a debugger would, one decision at a time. Suppose a colleague wrote the one-argument constructor with a mistake, so that its initializer list reads :re{r}, im{r}, and then a program declares complex b(2.0) and prints the imaginary part.