9.6. Constructors And Initializer Lists

Constructors are, first and foremost, just functions. They can range from simple to complex. However, constructors are special functions that are called automatically whenever a program creates (i.e., instantiates) a new object. The primary purpose of constructors is to construct or initialize an object. Visually, constructors are set apart from "regular" functions by two characteristics: (a) they have the same name as the class for which they are constructing objects, and (b) they do not have a return type.

Constructors

As you might suppose, constructors are an essential part of object-oriented programs, enough so that we name five different kinds to make them easier to talk about.

• Default
• Conversion
• Copy
• Move
• General

class Foo
{
 public:
        Foo();

        Foo(int x);

        Foo(int x, int y);
};
 

Foo f1;               // (a)
Foo* f2 = new Foo;
//Foo f1();
//Foo* f2 = new Foo();

Foo f3(5);            // (b)
Foo* f4 = new Foo(5);

Foo f5(5, 10);          // (c)
Foo* f6 = new Foo(5, 10);

Each constructor is designed to fill a specific programming need, but most classes will only need a few constructors - not all. The following sections describe each kind of constructor in detail, but the focus is on the constructor's visible operations. One object-oriented feature, polymorphism, requires that each object store a hidden pointer (called the vptr or virtual pointer). One of the tasks of every constructor is to initialize vptr, which it does by running code that the compiler automatically inserts into each constructor. If the class does not have any constructors, the compiler creates a simple default constructor to initialize the vptr. We'll explore polymorphism in more detail in a later chapter.

As described below, we typically distinguish constructors based on their parameters. However, we use the term "general constructor" to denote any constructor that doesn't fit into one of the other categories. Further confusing constructor identification, sometimes we need a general constructor having only one parameter, but we don't use it as a conversion constructor. Sometimes, the distinction between a general and conversion constructor depends on how we use it rather than the number of parameters. We'll see in the CString example later in the chapter that this can sometimes cause problems.

The Default Constructor

The primary characteristic that sets a default constructor apart from the other constructors is that it has no parameters. A default constructor often creates an "empty" object or an initialized object with default values. Although the text didn't state it at the time, many of our previous examples have relied on the string class default constructor that creates a string object that does not contain any characters. We can also use a default constructor to create an "empty" instance of our Time class.

class Time
{
    private:
        int   hours;
        int   minutes;
        int   seconds;
    public:
        Time() : hours(0), minutes(0), seconds(0) {}
};

class Time
{
    private:
        int   hours = 0;
        int   minutes = 0;
        int   seconds = 0;
};
 
 

class Time
{
    private:
        int   hours = 0;
        int   minutes = 0;
        int   seconds = 0;
    public:
        Time(int h, int m, int s)
            : hours(h), minutes(m), seconds(s) {}
};

class Time
{
    private:
        int   hours = 0;
        int   minutes = 0;
        int   seconds = 0;
    public:
        Time() {}
        Time(int h, int m, int s);
};

Time t1;
Time* t2 = new Time;

Time t3();			// error
Time* t4 = new Time();		// okay

Conversion Constructor

A conversion constructor typically has one parameter that it converts from the given type to an instance of the defining class (i.e., the class defining the constructor function). However, some conversion constructors do have multiple parameters, reinforcing the idea that we base the labels more on how we use and think about the constructor than on their parameter count. What the conversion means and how the conversion function works depends entirely on the source and destination types.

class Foo
{
        . 
        . 
        .

    public:
        Foo(Bar b);
};

class Time
{
    private:
        int   hours;
        int   minutes;
        int   seconds;

    public:
        Time(int s)
        {
            hours = s / 3600;
            s %= 3600;
            minutes = s / 60;
            seconds = s % 60;
        }
};

Copy Constructor

A copy constructor creates a new object by copying an existing object. C++ bases two critical and fundamental programming operations on the copy constructor:

1. Pass by value
2. Return by value

Therefore, whenever programs pass objects to or return them from functions by value, they create new objects by calling the copy constructor to copy an object from one program scope to another. The pass and return operations are so fundamental to programming that the compiler automatically generates a copy constructor for every class. In the previous examples, the copy constructor was simple enough for the compiler to create it automatically. Later, we will see more complex situations where the compiler-generated copy constructor is insufficient, and in such cases, we must replace it with one we write. However, writing a copy constructor presents a problem: Since the copy constructor implements pass- and return-by-value, how can we write a copy constructor function without causing infinite recursion? Answering that question underscores the characteristic distinguishing a copy constructor - the characteristic necessary to override the compiler-generated copy constructor correctly. Copy constructors always have a single reference parameter of the defining class type: ClassName(const ClassName& o);

class Person
{
    private:
        int    id;
        int    weight;
        double height;
    public:
        Person(const Person& p);
};

Person::Person(const Person& p)
{
    id = p.id;
    weight = p.weight;
    height = p.height;
}
 
 
 

fraction fraction::add(fraction f2)
{
    fraction temp;
    
    temp.numerator = . . .;
    temp.denominator = . . .;

    return temp;
}

fraction fraction::add(fraction f2)
{
    int   d = . . .;
    int   n = . . .;

    return fraction(n, d);
}

Move Constructor

Like the copy constructor, the move constructor can be identified by its distinctive parameter:

ClassName(ClassName&& o);

If a move constructor has additional arguments, they must have default values (i.e., default arguments). Unlike copy constructors, move constructors can take some or all the resources held by the argument object rather than copying them, leaving the original object in a valid but potentially incomplete state. The text only introduces the double ampersand, &&, denoting an r-value reference declarator, and the move constructor. You will revisit both in greater detail in the algorithms and data structures course.

General Constructor

No special syntax or pattern defines a general constructor. A general constructor does not fit into any of the categories described above. So, any constructor that has two or more parameters is a general constructor just because it's not (a) a default constructor (no parameters), (b) a conversion constructor (has one parameter that's not a reference), or (c) a copy constructor (one parameter that is a reference). It is possible to convert the first make_time function from the struct Time example into a general constructor:

Time::Time(int h, int m, int s)
{
    hours = h;
    minutes = m;
    seconds = s;
}

Initializer List Notation

One common task of constructor functions is initializing (i.e., assigning the first or initial value to) an object's member variables, regardless of the constructor's overall complexity. Although programmers can initialize members in the constructor's body, most practitioners consider it a better practice to initialize them with an initializer list. An initializer list is a compact notation equivalent to a sequence of assignment statements. However, they have the advantage of running before the constructor's body, so the member variables are ready to use as soon as the body runs. Initializer lists begin with a colon and appear between a function's parameter list and the body's opening brace. Initializer lists follow a simple pattern:

class fraction
{
    private:
        int   numerator;
        int   denominator;
    public:
        fraction(int n, int d) : numerator(n), denominator(d) {}
};

An initializer list is a comma-separated list of initializer elements. Each element behaves like an assignment, so numerator(n) is equivalent to numerator = n. The color coding in the figure above highlights the connection between a constructor's arguments and member variables: the first part of each element is the name of a member variable, and the second part (enclosed in parentheses) is the name of one of the function's parameters. With one exception, the list elements may appear in any order. We'll explore that exception, inheritance, in the next chapter.

fraction::fraction(int n, int d)
{
    numerator = n;
    denominator = d;

    int common = gcd(numerator, denominator);
    numerator /= common;
    denominator /= common;
}

fraction::fraction(int n, int d)
    : numerator(n), denominator(d)
{
    int common = gcd(numerator, denominator);
    numerator /= common;
    denominator /= common;
}
 
 

Every function must have exactly one body. The body is often empty in the case of simple constructors whose only purpose is to initialize the object's member variables. In the following example, the {} at the end is the function's empty body and not part of the initializer list.

Person(string a_name, double a_height, int a_weight) : name(a_name), height(a_height), weight(a_weight) {}

Initializer lists are a part of the function definition and not of the declaration or prototype. So, if the class only contains a function prototype and the function definition is in a separate .cpp file, then the initializer list goes with the function definition in the .cpp file:

class fraction
{
    private:
        int   numerator;
        int   denominator;
    public:
        fraction(int n, int d);
};

fraction::fraction(int n, int d)
    : numerator(n), denominator(d)
{
    int common = gcd(numerator, denominator);
    numerator /= common;
    denominator /= common;
}
 

class fraction
{
    public:
        fraction(int n, int d) {}
};

fraction::fraction(int n, int d)
 : numerator(n), denominator(d)
{
    . . . .
}

Default Arguments

Although the UML has always permitted class designers to specify initial values for member variables and function arguments, C++ originally did not allow programmers to initialize member variables in the class specification. So, programmers initialized member variables with constructors, and you may still see examples of this in existing code. However, C++ has always supported default arguments, which may be used with any C++ function (not just constructors). When we use default arguments with constructors, they must follow all of the rules listed in Chapter 6 (and it's probably a good idea to review those rules now).

+fraction(n: int = 0, d : int = 1)

fraction(int n = 0, int d = 1);

In "real world" C++ programs, it is common for the class specification to appear in a .h file and the member functions (including constructors) to appear in a .cpp file. When we follow this organization, there is one unfortunate aspect of initializer lists and constructor default arguments that we must memorize:

class fraction
{
    private:
        int   numerator;
        int   denominator;
    public:
        fraction(int n = 0, int d = 1);
};

fraction::fraction(int n, int d)
    : numerator(n), denominator(d)
{
    int common = gcd(numerator, denominator);
    numerator /= common;
    denominator /= common;
}
 

class fraction
{
    private:
        int   numerator = 0;
        int   denominator = 1;
    public:
        fraction() {}
        fraction(int n);
        fraction(int n, int d);
};

fraction  f1;
fraction* f2 = new fraction;

Constructor Chaining

Like any function, constructors can range from algorithmically simple to complex. Sometimes, complex constructors perform the same operations as simple ones, followed by additional operations befitting their complex nature. In many cases, we can avoid the overhead of writing and maintaining duplicate constructor code by putting the common, often simple, code in a basic constructor and allowing more advanced constructors to call the basic one. Java has always supported in-class constructor chaining by using this(...) as the name of an overloaded constructor and the number and type of arguments to differentiate between them. Before the adoption of the C++ 2011 standard, C++ did not permit in-class constructor chaining, but it does now, albeit with limitations.

class Table
{
    private:
        int   rows;
        int   cols;
        int**  array;
};

Table(int r, int c) : rows(r), cols(c)
{
    array = new int*[rows];
    for (int i = 0; i < rows; i++)
        array[i] = new int[cols];
}
 

Table(const Table& t) : Table(trows, cols)
{
    for (int i = 0; i < rows; i++)
        for (int j = 0; j < cols; j++)
            array[i][j] = array[i][j];
}

Table(const Table& t)
 : Table(trows, cols), member(10)
{
    .
    .
}

Chaining constructors works well when the operations of the called or delegated constructor (e.g., (b)) must or can run before the operations in the calling or delegating constructor (e.g., (c)). When that is not the case, the best we can do, in C++ or Java, is use a helper function to implement the common code.

display()
{
    ...;
    ...;
}

Window()
{
    ...;
    display();
}

Window(int x, int y)
{
    ...;
    display();
}

Window(int x, int y, int color)
{
    ...;
    display();
}