Initialisation

in modern C++
Version 1.1

Timur Doumler

@timur_audio

CppOnSea
5 February 2019
https://imgur.com/3wlxtI0 !2
!3
 This talk

• Different ways to initialise an object in C++

• In order of introduction: C, C++98, C++03, C++11, C++14, C++17
• The future: C++20
• Recommendations
• Overview table (updated!)

!5
!6
 Default initialisation

int main() {
int i;
}

!7
 Default initialisation

int main() {
int i;
return i; // Undefined behaviour!
}

!8
 Default initialisation

struct Foo {
int i;
int j;
};

int main() {
Foo foo;
return foo.i; // Undefined behaviour!

!9
 Default initialisation

class Foo {
public:
Foo() {}
int get_i() const noexcept { return i; }
int get_j() const noexcept { return j; }

private:
int i;
int j;
};

int main() {
Foo foo;
return foo.get_i(); // Undefined behaviour!
}

!10
 C++98: member initialiser list

class Foo {
public:
Foo() : i(0), j(0) {} // member initialiser list
int get_i() const noexcept { return i; }
int get_j() const noexcept { return j; }

private:
int i;
int j;
};

int main() {
Foo foo;
return foo.get_i();
}

!11
 C++11: default member initialisers

class Foo {
public:
Foo() {}
int get_i() const noexcept { return i; }
int get_j() const noexcept { return j; }

private:
int i = 0; // default member initialisers
int j = 0;
};

int main() {
Foo foo;
return foo.get_i();
}

!12
 Copy initialisation

int main() {
int i = 2;
}

!13
 Copy initialisation

int main() {
int i = 2;
}

int square(int i) {
return i * i;
}

!14
 Copy initialisation

int main() {
int i = 2;
• Initialiser starting with `=`, or
} • Passing argument by value, or
int square(int i) { • Returning by value
return i * i;
}

!15
 Copy initialisation

int main() {
int i = 2;
• Initialiser starting with `=`, or
} • Passing argument by value, or
int square(int i) { • Returning by value

return i * i;
}
• Copy init is never an assignment

!16
 Copy initialisation

int main() {
int i = 2;
• Initialiser starting with `=`, or
} • Passing argument by value, or
int square(int i) { • Returning by value

return i * i;
}
• Copy init is never an assignment
• If types don’t match, copy init
performs a conversion sequence

!17
 Aggregate initialisation

int i[4] = {0, 1, 2, 3};

!18
 Aggregate initialisation

int i[4] = {0, 1, 2, 3};

int j[] = {0, 1, 2, 3}; // array size deduction

!19
 Aggregate initialisation

int i[4] = {0, 1, 2, 3};

int j[] = {0, 1, 2, 3}; // array size deduction

struct Foo { // aggregate type

int i;
float j;
};

Foo foo = {1, 3.14159};

!20
 Aggregate initialisation

int i[4] = {0, 1, 2, 3};

int j[] = {0, 1, 2, 3}; // array size deduction

struct Foo { // aggregate type

int i;
float j;
};

Foo foo = {1, 3.14159}; // foo is aggregate-initialised;

// foo.i and foo.j are copy-initialised

!21
 Zero initialisation of aggregate elements

struct Foo {
int i;
int j;
};

int main() {
Foo foo = {1};
return foo.j;
}

!22
 Zero initialisation of aggregate elements

struct Foo {
int i;
int j;
};

int main() {
Foo foo = {1}; // elements with no initialiser are zero-initialised!
return foo.j; // OK, returns 0
}

!23
 Zero initialisation of aggregate elements

struct Foo {
int i;
int j;
};

int main() {
Foo foo = {1}; // elements with no initialiser are zero-initialised!
return foo.j; // OK, returns 0
}

int arr[100] = {}; // all elements are zero-initialised!

!24
 Brace elision

struct Foo {
int i;
int j;
};

struct Bar {
Foo f;
int k;
};

int main() {
Bar b = {1, 2};
return b.k; // What does this return?
}

!25
 Brace elision

struct Foo {
int i;
int j;
};

struct Bar {
Foo f;
int k;
};

int main() {
Bar b = {1, 2}; // Equivalent to Bar b = {{1, 2}, 0};
return b.k; // returns 0!
}

!26
 Static initialisation

static int i = 3; // Constant initialisation

!27
 Static initialisation

static int i = 3; // Constant initialisation

static int j; // Zero-initialisation

!28
 Static initialisation

static int i = 3; // Constant initialisation

static int j; // Zero-initialisation

int main()
{
return i + j; // OK, returns 3
}

!29
 Initialisation order fiasco

static Colour red = {255, 0, 0}; // Uh-oh :(

!30
 Initialisation order fiasco

static Colour red = {255, 0, 0}; // if constructor is constexpr (C++11)

// -> constant initialisation :)

!31
 What have we got so far?

• Default initialisation (no initialiser)

• built-in types: uninitialised, UB on access
• class types: default constructor
• Copy initialisation (`= value`, pass-by-value, return-by-value)
• Aggregate initialisation (`= {args}`)
• Elements without initialisers undergo zero initialisation
• Static initialisation
• zero-initialisation by default
• constant initialisation (`= constexpr`)
!32
Foo foo(1, 2); // C++ introduces constructors!

!34
Foo foo(1, 2);
int i(3);

!35
 Direct initialisation

Foo foo(1, 2);

int i(3);

!36
 Direct initialisation

Foo foo(1, 2);

int i(3);

“whenever the initialiser is an argument list in parens”

!37
 Direct initialisation

Foo foo(1, 2);

int i(3);

• Differences to copy initialisation:

• For built-in types: no difference
• For class types:
• Can take more than one argument
• Does not perform “conversion sequence”,

instead just calls constructor using normal overload resolution

!38
 Direct initialisation

struct Foo {
explicit Foo(int) {}
};

Foo foo1 = 1;   // ERROR

Foo foo2(2);    // ok

!39
 Direct initialisation

struct Foo {
explicit Foo(int) {}
Foo(double) {}
};

Foo foo1 = 1; // calls Foo(double)

Foo foo2(2); // calls Foo(int)

!40
 Direct initialisation

Foo(1, 2); // constructor call notation

auto* foo_ptr = new Foo(2, 3); // new-expr with (args)
static_cast<Foo>(bar); // casts

!41
 Problem: most vexing parse

struct Foo {};

struct Bar {
Bar(Foo) {}
};

int main() {
Bar bar(Foo());
}

!42
 Problem: most vexing parse

struct Foo {};

struct Bar {
Bar(Foo) {}
};

int main() {
Bar bar(Foo()); // This is a function declaration :(
}

!43
 What have we got so far?

• Default initialisation (no initialiser)

• Copy initialisation (`= value`, pass-by-value, return-by-value)
• Aggregate initialisation (`= {args}`)
• Static initialisation
• Direct initialisation (argument list in parens)
• Problem: most vexing parse

!44
03
 Value initialisation

int main() {
return int();
}

!46
 Value initialisation

int main() {
return int(); // UB in C++98, OK since C++03
}

!47
 Value initialisation

int main() {
return int(); // UB in C++98, OK since C++03
}

“whenever the initialiser is a pair of empty parens”

!48
 Value initialisation

When the initialiser is a pair of empty parens:

• If type has a user-provided default c’tor, it is called
• Otherwise, you get zero initialisation

!49
 Value initialisation

struct Foo {
int i;
};

Foo get_foo() {
return Foo();
}

int main() {
return get_foo().i;
}

!50
 Value initialisation

struct Foo {
int i;
};

Foo get_foo() {
return Foo(); // Value initialisation
}

int main() {
return get_foo().i; // OK since C++03, returns 0
}

!51
 Value initialisation

struct Foo {
Foo() {} // user-provided ctor!
int i;
};

Foo get_foo() {
return Foo(); // Value initialisation
}

int main() {
return get_foo().i; // value is uninitialised -> UB!!!
}

!52
 Value initialisation

struct Foo {
Foo() = default; // (since C++11) user-defined, but not user-provided
int i;
};

Foo get_foo() {
return Foo(); // Value initialisation
}

int main() {
return get_foo().i; // OK, returns 0
}

!53
 Value initialisation

struct Foo {
Foo();
int i;
};

Foo::Foo() = default; // out-of-line counts as user-provided!

Foo get_foo() {
return Foo(); // Value initialisation
}

int main() {
return get_foo().i; // value is uninitialised -> UB!!!
}

!54
 What have we got so far?
• Default initialisation (no initialiser)
• Copy initialisation (`= value`, pass-by-value, return-by-value)
• Aggregate initialisation (`= {args}`)
• Static initialisation
• Direct initialisation (argument list in parens)
• Value initialisation (empty parens)
• Performs default-init or zero-init
• Problem: most vexing parse

!55
++11
 “Uniform initialisation”

• We’ve got too many different initialisation syntaxes

• Parens are vexing
• We cannot do:

std::vector<int> vec = {0, 1, 2, 3, 4};

• Instead we have to do:

std::vector<int> vec;
vec.reserve(5);
vec.push_back(0);
vec.push_back(1);
vec.push_back(2);
vec.push_back(3);
vec.push_back(4); !57
 “Uniform initialisation”

• So let’s add one more initialisation syntax!

Foo foo{1, 2};

• It’s called list-initialisation

• Idea: it does “everything”

!58
 List initialisation

Direct-list-initialisation Copy-list-initialisation
Foo foo{1, 2}; Foo foo = {1, 2};

!59
 List initialisation

Direct-list-initialisation Copy-list-initialisation
Foo foo{1, 2}; Foo foo = {1, 2};

braced-init-list

!60
 How does this work?

std::vector<int> vec{0, 1, 2, 3, 4};

!61
 std::initializer_list

template <typename T>

class vector {
// stuff...
vector(std::initializer_list<T> init);  // init list ctor
};

std::vector<int> vec{0, 1, 2, 3, 4}; // calls that^

!62
!63
!64
 std::initializer_list

std::vector<int> v(3, 0); // vector contains 0, 0, 0

std::vector<int> v{3, 0}; // vector contains 3, 0

!65
 std::initializer_list

std::string s(48, 'a'); // "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"

std::string s{48, 'a'};

!66
 std::initializer_list

std::string s(48, 'a'); // "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"

std::string s{48, 'a'}; // "0a"

!67
 std::initializer_list

template <typename T, size_t N>

auto test() {
return std::vector<T>{N};
}

int main() {
return test<std::string, 3>().size(); // what does this return??
}

!68
 List initialisation
• For aggregate types:
• aggregate init
• For built-in types:
• `{a}` is direct init, `= {a}` is copy-init
• For class types:
• First, greedily try to call a ctor that takes a std::initializer_list
• If there is none: direct-init 

(or copy-init if `= {a}` and a is a single element)
!69
 Empty braces {} are special
• For aggregate types: aggregate init (all elements zeroed)
• Only call std::initializer_list ctor if there is no default ctor

template <typename T>

struct Foo {
Foo();
Foo(std::initializer_list<T>);
};

int main() {
Foo<int> foo{}; // calls default ctor!
}

!70
 Empty braces {} are special
• For aggregate types: aggregate init (all elements zeroed)
• Only call std::initializer_list ctor if there is no default ctor
• Otherwise: value initialisation

!71
 Empty braces {} are special
• For aggregate types: aggregate init (all elements zeroed)
• Only call std::initializer_list ctor if there is no default ctor
• Otherwise: value initialisation
struct Foo {
Foo() = default;
int i;
};

int main() {
Foo foo{}; // value init -> zero init, no vexing parse!
return foo.i; // returns 0
}

!72
 Empty braces {} are special
• For aggregate types: aggregate init (all elements zeroed)
• Only call std::initializer_list ctor if there is no default ctor
• Otherwise: value initialisation
struct Foo {
Foo() {} // user-provided ctor!
int i;
};

int main() {
Foo foo{}; // value init -> default ctor gets called
return foo.i; // uninitialised! UB
}

!73
 List init: no narrowing conversions!

int main() {
int i{2.0}; // Error!
}

!74
 List init: nested braces

• The nice case:

std::map<std::string, int> my_map {{"abc", 0}, {"def", 1}}; 


!75
 List init: nested braces

• The nice case:

std::map<std::string, int> my_map {{"abc", 0}, {"def", 1}}; 


• The evil case:

std::vector<std::string> v1 {"abc", "def"}; // OK
std::vector<std::string> v2 {{"abc", "def"}}; // ???

!76
 List init: nested braces

• The nice case:

std::map<std::string, int> my_map {{"abc", 0}, {"def", 1}}; 


• The evil case:

std::vector<std::string> v1 {"abc", "def"}; // OK
std::vector<std::string> v2 {{"abc", "def"}}; // Undefined behaviour!!!

!77
 Copy list init

• The nice case:

std::map<std::string, int> my_map {{"abc", 0}, {"def", 1}}; 


• The evil case:

std::vector<std::string> v1 {"abc", "def"}; // OK
std::vector<std::string> v2 {{"abc", "def"}}; // Undefined behaviour!!!

!78
 Copy list init

Widget<int> f1()
{
return {3, 0}; // copy-list init
}

void f2(Widget);
f2({3, 0}); // copy-list init

!79
!80
 What have we got so far?
• Default initialisation (no initialiser)
• Copy initialisation (`= value`, pass-by-value, return-by-value)
• Aggregate initialisation (`= {args}`)
• Static initialisation
• Direct initialisation (argument list in parens)
• Value initialisation (empty parens)
• List initialisation (`{args}` is direct-list-init, `= {args}` is copy-list-init)
• Performs aggregate-init or direct-init or copy-init or value-init
• Problems with std::initializer_list, useless in templates
!81
14
 Fix #1: aggregates can have DMIs

struct Foo {
int i = 0;
int j = 0;
};

Foo foo{1, 2}; // OK since C++14

!83
 Fix #2: auto + list-initialisation

int i = 3; // int
int i(3); // int
int i{3}; // int
int i = {3}; // int

auto i = 3; // int
auto i(3); // int
auto i{3}; // std::initializer_list<int> in C++11
auto i = {3}; // std::initializer_list<int> in C++11

!84
 Fix #2: auto + list-initialisation

int i = 3; // int
int i(3); // int
int i{3}; // int
int i = {3}; // int

auto i = 3; // int
auto i(3); // int
auto i{3}; // int since C++14, ill-formed if more than one initialiser
auto i = {3}; // std::initializer_list<int> (always)

!85
17
 Guaranteed copy elision

auto num = 1;
auto foo = Foo{2, 3};

!87
 Guaranteed copy elision

auto foo = std::atomic<int>{0}; // C++11/14: Error

// atomic is neither copyable nor movable

!88
 Guaranteed copy elision

auto foo = std::atomic<int>{0}; // Works in C++17 :)

!89
 Guaranteed copy elision

auto foo = std::atomic<int>{0}; // Works in C++17 :)

“Almost always auto” is now “Always auto” !! :)

!90
Initialisation and CTAD

!91
20
!92
 Designated initialisation

struct Foo {
int a;
int b;
int c;
};

int main() {
Foo foo{.a = 3, .c = 7};
}

!93
 Designated initialisation

struct Foo { Only for aggregate types.

int a;
C compatibility feature.
int b;
int c; Works like in C99, except:
};
• not out-of-order 

int main() { Foo foo{.c = 7, .a = 3} // Error
Foo foo{.a = 3, .c = 7}; • not nested 

}
Foo foo{.c.e = 7} // Error
• not mixed with regular initialisers

Foo foo{.a = 3, 7} // Error
• not with arrays 

int arr[3]{.[1] = 7} // Error

!94
 Array size deduction in new-expressions
http://wg21.link/p1009

double a[]{1,2,3}; // OK
double* p = new double[]{1,2,3}; // Error in C++17, will be OK in C++20

!95
 Aggregates can no longer declare constructors
http://wg21.link/p1008

struct Foo {
Foo() = delete;
int i;
int j;
};

Foo foo1; // Error

Foo foo2{}; // OK in C++17! Will be error in C++20

!96
 Problems with list init:

• Difficult to see when it’ll call a std::initializer_list constructor,


and when it won’t

• std::initializer_list doesn’t work with move-only types

• Useless in templates

(you can’t write a make_unique that works for aggregates!)


• Does not work with macros at all:

assert(Foo{2, 3}); // This breaks the preprocessor :(

!97
 Aggregate initialisation from parens
http://wg21.link/p0960

struct Foo {
int i;
int j;
};

Foo foo(1, 2); // will work in C++20!

!98
 Aggregate initialisation from parens
http://wg21.link/p0960

struct Foo {
int i;
int j;
};

Foo foo(1, 2); // will work in C++20!

int arr[3](0, 1, 2); // will work in C++20!

!99
 Aggregate initialisation from parens
http://wg21.link/p0960

struct Foo {
int i;
int j;
};

Foo foo(1, 2); // will work in C++20!

int arr[3](0, 1, 2); // will work in C++20!

Idea: in C++20, () and {} will do the same thing!

Except:
• () does not call std::initializer_list constructors
• {} does not consider narrowing conversions
!100
 Recommendations:

• Use auto
• Use direct member initialisers (DMIs)
• Use `= value` for int and other simple value types
• Use `= {args}` for aggregate-init, std::initializer_list, DMIs

→ Recommendation for aggregates might change for C++20!)
• Use `{}` for value-init
• Use `(args)` to call constructors that take arguments

→ This is the controversial one. Other people say: use `{args}`
!101
Initialisation in C++17 Version 2 – Copyright (c) 2019 Timur Doumler

Default init Copy init Direct init Value init Empty braces Direct list init Copy list init
Type var ; = value; (args); (); {}; = {}; {args}; = {args};
Built-in types Uninitialised. Initialised with 1 arg: Init with arg Zero-initialised Zero-initialised 1 arg: Init with arg 1 arg: Init with arg
Variables w/ static value (via conver- >1 arg: >1 arg: >1 arg:
storage duration: sion sequence) Doesn’t compile Doesn’t compile Doesn’t compile
Zero-initialised
auto Doesn’t compile Initialised with Initialised with Doesn’t compile Doesn’t compile 1 arg: Init with arg Object of type
value value >1 arg: std::initializer_list
Doesn’t compile
Aggregates Uninitialised. Doesn’t compile Doesn’t compile Zero-initialised*** Aggregate init** 1 arg: implicit 1 arg: implicit copy/
Variables w/ static (but will in C++20) copy/move ctor if move ctor if
storage duration: possible. Otherwise possible. Otherwise
Zero-initialised*** aggregate init** aggregate init**
Types with Default ctor Matching ctor (via Matching ctor Default ctor Default ctor if there std::initializer_list std::initializer_list
std::initializer_list conversion is one, otherwise ctor if possible, ctor if possible,
ctor sequence), explicit std::initializer_list otherwise matching otherwise matching
ctors not considered ctor ctor ctor****
Other types with Members are Matching ctor (via Matching ctor Zero-initialised*** Zero-initialised*** Matching ctor Matching ctor****
no user-provided* default-initialised conversion
default ctor sequence), explicit
ctors not considered
Other types Default ctor Matching ctor (via Matching ctor Default ctor Default ctor Matching ctor Matching ctor****
conversion
sequence), explicit *not user-provided = not user-declared, or user-declared as =default inside the class definition
ctors not considered **Aggregate init copy-inits all elements with given initialiser, or value-inits them if no initialiser given
***Zero initialisation zero-initialises all elements and initialises all padding to zero bits
****Copy-list-initialisation considers explicit ctors, too, but doesn’t compile if such a ctor is selected
Thank you!

@timur_audio
includecpp.org
103