Copying Values into Container Storage

Often we want an object that already holds several values the moment it is declared. A container such as a vector of numbers is a common case. The slow way is to create an empty object and then add each element one at a time. C++ offers a shorter way: write the values directly, inside braces, and let the object be built from them. The mechanism that makes this possible is a special kind of constructor called an initializer-list constructor.

In this article we will follow one braced list from the moment it is written to the moment the finished object exists. The running example is a class named Vector, whose constructor accepts a list of double values. Keep the question in mind as you read: how many elements will the object hold, and how did the values get there?

The braces are not passed to the constructor as text, and they are not handed over as a loose set of separate arguments. Instead, the list of values is packaged into a single std::initializer_list object, and that one object is what the constructor receives. The compiler performs this packaging whenever a braced list is used, so the same mechanism applies to any list of values written in braces, as long as the class provides a suitable constructor.

Read the diagram from top to bottom. The braced list becomes one std::initializer_list object before the constructor runs. The constructor then copies values from that object into storage belonging to the Vector. The number of values inside the braces determines how many elements the object holds, because the element count comes from the same list.

The key point is that std::initializer_list is a way of handing over the list, not a container that the object keeps. The list is read once. Its values are used as a source, and the object keeps its own copy of those values in its own memory. The picture below shows the list as a view over a group of values, with the cells holding the values in order.

An initializer-list constructor is recognized by its parameter. Its argument has the type std::initializer_list followed by the type of the values it holds. In the Vector class, the constructor takes a list of double values, so the parameter type is std::initializer_list<double>. The declaration below is the form used in the source.

Once the constructor has the list, it must give the object its own storage and fill it. The member initializers allocate a new array of doubles sized by the list, and the element count is recorded by converting the list's size to an int. The body then copies every value from the list into the newly allocated storage. A simplified sketch of that shape is shown below. The copy loop is an illustration of the copying step described in the source, not a complete class.