List, Aggregate, and Designated Initialization

At this point, we’re likely very familiar with initializing objects by specifying the type of object we want to construct, and a list of values to pass to a constructor defined as part of that type.

Typically, this looks something like this:

1#include <iostream>
2
3struct Vec3 {
4  // Constructor using a member initializer list
5  Vec3(int x, int y, int z)
6    : x{x}, y{y}, z{z}
7  {}
8
9  int x{0};
10  int y{0};
11  int z{0};
12
13  void Log(){
14    std::cout
15      << "x=" << x
16      << ", y=" << y
17      << ", z=" << z << '\n';
18  }
19};
20
21int main(){
22  // Calling the constructor to create an object
23  Vec3 Vector{1, 2, 3};
24  Vector.Log();
25}

1x=1, y=2, z=3

This is referred to as list initialization, and the previous example is only one way to use it.

In this lesson, we’ll cover some of the other useful scenarios. We’ll also introduce other forms of list initialization, including aggregate initialization, and designated initialization.

List Initialization during Assignment

When we want to construct a new object to assign to a variable, we don’t need to specify the type of the new object. After all, it will inherently have the same type as the variable we’re storing it in.

This goes without saying when the type can be initialized from a single value:

1int Number { 1 };
2
3// We can include the type during assignment...
4Number = int{2};
5
6// ...but we don't need to
7Number = 3;

But the same applies to any type. If we need multiple constructor arguments to create the new object we’re assigning to our variable, we just need to provide them as a list:

1#include <iostream>
2
Vec3 Struct (Unchanged)|Show
3struct Vec3 {/*...*/};
16
17int main(){
18  Vec3 Vector;
19  Vector = {1, 2, 3};
20  Vector.Log();
21}

1x=1, y=2, z=3

List Initialization with Functions

Similar shortcuts are available when constructing an object to immediately return it. In scenarios like this, we need to provide a list of constructor arguments.

The compiler knows what type we’re constructing - it will be the return type of the function:

1#include <iostream>
2
Vec3 Struct (Unchanged)|Show
3struct Vec3 {/*...*/};
16
17Vec3 GetVector(){
18  return {1, 2, 3};
19}
20
21int main(){
22  GetVector().Log();
23}

1x=1, y=2, z=3

The same logic applies when constructing an object to pass to a function. We only need to pass the constructor arguments - the type can be inferred from the function’s parameter list:

1#include <iostream>
2
Vec3 Struct (Unchanged)|Show
3struct Vec3 {/*...*/};
16
17void HandleVector(Vec3 V){
18  V.Log();
19}
20
21int main(){
22  HandleVector({1, 2, 3});
23}

1x=1, y=2, z=3

List Initialization within Constructors

As a final example, we can also provide a simple list of arguments to construct an object within the member initializer list of another constructor.

Below, our Character constructor is constructing a Vec3 using some of its parameters. The constructor doesn’t need to specify the type it’s constructing - just the variable that will be used.

The compiler knows the variable - Position, in this case, is a Vec3 - so it understands how to use the list:

1#include <iostream>
2
Vec3 Struct (Unchanged)|Show
3struct Vec3 {/*...*/};
16
17struct Character {
18  Character(
19    std::string Name, int x, int y, int z) :
20      Name{Name},
21      Position{x, y, z}
22    {}
23
24  std::string Name;
25  Vec3 Position;
26};
27
28int main(){
29  Character Player("Anna", 1, 2, 3);
30  std::cout << Player.Name << " Position: ";
31  Player.Position.Log();
32}

1Anna Position: x=1, y=2, z=3

We covered member initializer lists in more detail in the introductory course:

Member Initializer Lists

This lesson introduces Member Initializer Lists, focusing on their advantages for performance and readability, and how to use them effectively

Storing Initialization Lists using std::initializer_list

Sometimes, we need to store initializer lists as standalone objects. The std::initializer_list template class is designed for this. It accepts a single template parameter, representing the type of values we’re storing in the list.

1#include <iostream>
2
3void Log(std::initializer_list<int> Numbers){
4  for (auto x : Numbers) {
5    std::cout << x << ", ";
6  }
7}
8
9int main(){
10  Log({1, 2, 3, 4, 5});
11}

11, 2, 3, 4, 5,

Often, std::initializer_lists are used in scenarios where we need to forward arguments from one constructor to another.

Below, we’ve laid the basic foundations of a custom container type. This container accepts a list of initial values, which allows it to be initialized using an API that will be familiar:

1CustomContainer Numbers{1, 2, 3, 4, 5};

Below, our CustomContainer type captures initialization values as a std::initializer_list within a constructor. This is so the initial collection can be forwarded to a private std::vector, which manages our type's underlying storage:

1#include <iostream>
2#include <vector>
3
4template <typename T>
5class CustomContainer {
6public:
7  CustomContainer(
8    std::initializer_list<T> Contents) :
9    Container{Contents}{}
10
11  auto begin() const{
12    return Container.begin();
13  }
14
15  auto end() const{ return Container.end(); }
16
17private:
18  std::vector<T> Container;
19};
20
21int main(){
22  CustomContainer Numbers{1, 2, 3, 4, 5};
23
24  for (int x : Numbers) {
25    std::cout << x << ", ";
26  }
27}

11, 2, 3, 4, 5,

A std::initializer_list is a lightweight, read-only wrapper. As such, it is fast to copy, so generally passed by value rather than by reference.

std::initializer_list is also a homogenous container. That is, every value it contains must be the same type.

A container that can store a variety of value types is referred to as heterogenous. Standard library support for these types of containers is currently limited. The closest heterogeneous equivalent to a std::initializer_list is std::tuple, which we covered in an earlier lesson:

Tuples and std::tuple

A guide to tuples and the std::tuple container, allowing us to store objects of different types.

Aggregate Initialization

Previously, we’ve seen when we’re working with a simple type, we can initialize objects simply by providing values for the data members. Our Vec3 struct can be initialized from a list of 3 int objects, even though it has no such constructor defined:

1#include <iostream>
2
Vec3 Struct (Unchanged)|Show
3struct Vec3 {/*...*/};
16
17int main(){
18  Vec3 V{1, 2, 3};
19  V.Log();
20}

In this example, our Vec3 struct had declared public data members x, y, and z - in that order, and we created an object using a list of 1, 2, and 3 - in that order.

As such, our object is initialized with those values, and our program output is:

1x=1, y=2, z=3

This is referred to as aggregate initialization. It only works with aggregates.

Aggregates are simple structs, classes, and unions that do not use some of the more advanced features. Specifically, as of C++23, for our type to be an aggregate, it can not have:

• any user-defined constructors
• any non-public variables, unless they’re inherited
• any virtual functions
• any private, protected, or virtual base classes

If our type meets this criterion, it is an aggregate, and its objects can be initialized using aggregate initialization.

Designated Initialization

As of C++20, we can initialize aggregates using designated initializers. Alongside each value, we provide the name of the field we’re initializing, prefixed by a period. Using designated initializers, our previous example would look like this:

1#include <iostream>
2
Vec3 Struct (Unchanged)|Show
3struct Vec3 {/*...*/};
16
17int main(){
18  Vec3 V{.x = 1, .y = 2, .z = 3};
19  V.Log();
20}

1x=1, y=2, z=3

Within a designated initializer, the fields still need to be in the same order as defined within our type. The main advantage is they allow us to omit some of the fields from the list.

Below, we use a designated initializer to define values for x and z, omitting y. Therefore, y takes on the default value defined in the struct declaration:

1#include <iostream>
2
Vec3 Struct (Unchanged)|Show
3struct Vec3 {/*...*/};
16
17int main(){
18  Vec3 V{.x = 1, .z = 3};
19  V.Log();
20}

1x=1, y=0, z=3

Summary

In this lesson, we explored various initialization techniques, including list, aggregate, and designated initialization.

Main Points Learned:

• List initialization, including its use in object construction and assignment.
• How to use aggregate initialization to instantiate objects of simple types.
• The introduction and advantages of designated initialization in C++20, allowing for more readable and selective assignment of object members.
• Practical applications of these initialization techniques in various contexts, such as function returns, parameter passing, and within constructors
• The role of std::initializer_list for capturing and forwarding lists of homogenous values.

Next Lesson

User Defined Conversions

Learn how to add conversion functions to our classes, so our custom objects can be converted to other types.

ContinueView Course