Constructors and Initialization in C++

Every object of a class holds data, and that data has to start somewhere. Imagine a complex number class that stores a real part and an imaginary part. Before any arithmetic can happen, each stored part needs a value. This article answers two questions: how a class arranges for a starting value to be set at the moment an object comes into existence, and why that arrangement matters for correctness. The same mechanism also handles the other end of an object's life, where memory the object obtained must be given back.

Before you read the explanation, try to predict the output of the small program below. It defines a class whose constructor and destructor each print one line, and it creates one object inside an inner block. Think about the order in which the lines should appear, then compare your answer with the reveal.

A constructor has the same name as its class and no return type written in front of it. It is invoked automatically when an object is created. The programmer does not call it as an ordinary function after the object exists; the declaration itself triggers it.

Two things happen inside a constructor. First, it can allocate resources the object needs, such as memory from the free store. Second, it initializes the members of the object. The member initializer list, written after a colon, is the place where incoming values are assigned into the stored parts. In a constructor written as Complex(double r, double i) : re{r}, im{i}, the parameters r and i are only placeholders for the values passed in. The stored members are re and im, and the initializer list is what copies the values into them.

A complex number has two stored parts, so it is a good object for tracing what construction actually produces. The sketch below is an illustrative version of such a class with three constructors. All three share the class name, differ only in their parameter lists, and assign their values through initializer lists.

Constructors can be overloaded, which means one name can name several constructors that accept different numbers and types of arguments. The compiler picks among them by looking at the arguments present in the declaration. The three Complex constructors above are a concrete instance of this rule. The name Complex is the same in all three, and the parameter list is the only thing that distinguishes them.

The selection process can be followed one decision at a time, the same way a debugger would step through it. Start with the declaration. If no arguments are given, the constructor that takes no arguments is the one that matches. If arguments are given, the compiler checks whether their count and types match one of the constructors. When one matches, that constructor runs. When none does, the declaration is rejected at compile time, so the object is never built.

Construction is not only about setting member values. A constructor can also acquire a resource, such as an array allocated with new. The destructor is the matching function that releases it. Its name is a tilde followed by the class name, so a class named Vector has the constructor Vector and the destructor ~Vector. The destructor releases the resource with delete. The two functions work as a pair: whatever the constructor takes from the free store, the destructor is responsible for returning.

The Vector class is the running example. A container is an object that holds a collection of elements, and Vector is simple to understand, provides range-checked access, and can report its size so that you can loop over its elements. It has one serious flaw: it obtains memory for its elements with new, and nothing in the class gives that memory back until a destructor is added. The sketch below is a simplified version of the class, with error handling left out on purpose so that the core idea stays visible.

Users of Vector never call the destructor themselves. They create and use Vector objects much as they would variables of built-in types, and the cleanup happens without their intervention. The rules for naming, scope, allocation, and lifetime that apply to an int also apply to a Vector, so the destructor runs as the object's lifetime ends.

A language-level garbage collector would be one alternative, but C++ does not depend on one. Some environments have no collector, and sometimes a programmer wants precise control over when memory is freed for logical or performance reasons. The destructor is the mechanism the language provides to guarantee that memory obtained in a constructor is eventually released.

Follow a single example through its life. Suppose a program creates a Vector with three elements inside a function, uses it, and then the function returns. The states happen in a fixed order, and each one has a specific effect on the resource.

Resource Acquisition Is Initialization, usually abbreviated RAII, is the technique of acquiring a resource in a constructor and releasing it in a destructor. It is the best-known basis for most C++ general resource management techniques. Its payoff is that it lets code avoid what the source calls naked new and naked delete operations. A naked new is an allocation sitting in general-purpose code, and a naked delete is a release written by hand in that same code.

RAII keeps allocations buried inside the implementation of a well-behaved abstraction, such as Vector, so that everyday code does not have to remember to clean up. Avoiding naked new and naked delete makes code far less error-prone and far easier to keep free of resource leaks.