C++20 the small things - Timur Doumler

Timur Doumler
CoreHard Autumn Conference
30 November 2019
C++20:
The small things
@timur_audio
Version 1.4

11
1 Initialisation
2 Structured bindings
3 Lambdas
4 Templates
5 constexpr
6 Miscellaneous

12
1 Initialisation
3 Lambdas
4 Templates
5 constexpr
6 Miscellaneous

Aggregates
13
struct Widget {
int a;
bool b;
int c;
};

Aggregates
14
struct Widget {
int a;
bool b;
int c;
};
int main() {
Widget widget = {3, true};
}

Designated initialisers
15
struct Widget {
int a;
bool b;
int c;
};
int main() {
Widget widget{.a = 3, .c = 7};
}

16
struct Widget {
int a;
bool b;
int c;
};
int main() {
Widget widget{.a = 3, .c = 7};
}
Only for aggregate types.
C compatibility feature.
Works like in C99, except:
• not out-of-order
Widget widget{.c = 7, .a = 3} // Error
• not nested
Widget widget{.c.e = 7} // Error
• not mixed with regular initialisers
Widget widget{.a = 3, 7} // Error
• not with arrays
int arr[3]{.[1] = 7} // Error
Designated initialisers

18
Aggregates can no longer declare constructors

19
struct Widget {
Widget() = delete;
};
Widget w1; // Error

20
struct Widget {
Widget() = delete;
};
Widget w1; // Error
Widget w2{}; // OK in C++17!

21
struct Widget {
Widget() = delete;
};
Widget w1; // Error
Widget w2{}; // OK in C++17! Will be error in C++20

• Does not work with macros:
22
assert(Widget(2, 3)); // OK
C++17 problems with aggregate initialisation:

23
assert(Widget{2, 3}); // Error: this breaks the preprocessor :(

• Can’t do perfect forwarding in templates
• can’t write emplace or make_unique that works for aggregates :(
24
assert(Widget{2, 3}); // Error: this breaks the preprocessor :(

25
struct Widget {
int i;
int j;
};
Widget widget(1, 2); // will work in C++20!
C++20: Direct-initialisation of aggregates

26
struct Widget {
int i;
int j;
};
int arr[3](0, 1, 2); // will work in C++20!

27
struct Widget {
int i;
int j;
};
int arr[3](0, 1, 2); // will work in C++20!
So in C++20, (args) and {args} will do the same thing!
Except:
• () does not call std::initializer_list constructors
• {} does not allow narrowing conversions

28
struct Colour
{
Colour(int r, int g, int b) noexcept;
};
constinit

29
struct Colour
{
};
namespace Colours
{
const Colour red = {255, 0, 0};
}
constinit

30
struct Colour
{
};
namespace Colours
{
const Colour red = {255, 0, 0}; // dynamic initialisation
}
constinit

31
struct Colour
{
};
namespace Colours
{
const Colour red = {255, 0, 0}; // dynamic initialisation
} // -> initialisation order fiasco -> UB :(
constinit

32
struct Colour
{
constexpr Colour(int r, int g, int b) noexcept;
};
namespace Colours
{
constexpr Colour red = {255, 0, 0};
}
constinit

33
struct Colour
{
};
namespace Colours
{
constexpr Colour red = {255, 0, 0}; // constant initialisation :)
}
constinit

struct Colour
{
};
namespace Colours
{
Colour backgroundColour = getBackgroundColour();
}
34
constinit

struct Colour
{
};
namespace Colours
{
Colour backgroundColour = getBackgroundColour(); // const or dynamic init?
}
35
constinit

struct Colour
{
};
namespace Colours
{
constinit Colour backgroundColour = getBackgroundColour();
}
36
constinit

37
constinit
struct Colour
{
};
namespace Colours
{
constinit Colour backgroundColour = getBackgroundColour();
} // ^^^^^^ only compiles if init happens at compile time :)

Database getDatabase();
for (auto&& user : getDatabase().getUsers())
{
registerUser(user);
}
38
Range-based for with initialiser
C++17

for (auto&& user : getDatabase().getUsers()) // maybe undefined behaviour!
{
registerUser(user);
}
39
C++17

auto db = getDatabase();
for (auto&& user : db.getUsers())
{
registerUser(user);
}
40
C++17

{
auto db = getDatabase();
for (auto&& user : db.getUsers())
{
registerUser(user);
}
}
41
C++17

42
for (auto db = getDatabase(); auto&& user : db.getUsers())
{
registerUser(user);
}
C++20

43
1 Initialisation
3 Lambdas
4 Templates
5 constexpr
6 Miscellaneous

44
struct Widget
{
int i;
bool b;
};
auto [a, b] = getWidget();

45
struct Widget
{
int i;
bool b;
};
static [a, b] = getWidget(); // Error in C++17
thread_local [a, b] = getWidget(); // Error in C++17

46
struct Widget
{
int i;
bool b;
};
static [a, b] = getWidget(); // OK in C++20
thread_local [a, b] = getWidget(); // OK in C++20

47
struct Widget
{
int i;
bool b;
};
auto f = [a]{ return a > 0; }; // Error in C++17:
// capture ‘a’ does not name a variable

48
struct Widget
{
int i;
bool b;
};
auto f = [a]{ return a > 0; }; // OK in C++20

49
struct Widget
{
int i;
bool b;
};
auto f = [a]{ return a > 0; }; // OK in C++20
// copies ‘a’, not the whole object

50
1 Initialisation
3 Lambdas
4 Templates
5 constexpr
6 Miscellaneous

template<class F, class... Args>
auto delay_invoke(F f, Args... args) {
return [f = std::move(f), ...args = std::move(args)]() -> decltype(auto) {
return std::invoke(f, args...);
};
}
51
C++20: pack expansion allowed in lambda init capture

52
– Lambdas are allowed in unevaluated contexts
– Lambdas (without captures) are default-constructible
and assignable
More C++20 lambda features:

53
and assignable
decltype([]{})

54
and assignable
decltype([]{}) f;

55
and assignable
class Widget
{
decltype([]{}) f;
};

56
template <typename T>
using MyPtr = std::unique_ptr<
T, decltype([](T* t) { myDeleter(t); })>;
MyPtr<Widget> ptr;

57
using MyPtr = std::unique_ptr<
T, decltype([](T* t) { myDeleter(t); })>;
MyPtr<Widget> ptr;
using WidgetSet = std::set<
Widget,
decltype([](Widget& lhs, Widget& rhs) { return lhs.x < rhs.x; })>;
WidgetSet widgets;

58
Generic lambdas / functions
auto f = [](auto a){
return a * a;
};

59
auto f = [](auto a){
return a * a;
};
auto f(auto a) { // Generic *functions* – OK since C++20 :)
return a * a;
}

60
void f(std::vector<T> vector) {
// ...
}

61
void f(std::vector<T> vector) {
// ...
}
// C++20:
auto f = []<typename T>(std::vector<T> vector) {
// ...
};

62
1 Initialisation
3 Lambdas
4 Templates
5 constexpr
6 Miscellaneous

63
Non-type template parameters (NTTPs)

64
template <int size>
struct Widget
{
std::array<int, size> a;
};

65
template <int size>
struct Widget
{
std::array<int, size> a;
};

66
C++20: floating-point NTTPs
template <double x>
struct Filter
{
std::array<double, 2> coefficients = {x, 0.5 * x * x};
// stuff...
};

67
C++20: class-type NTTPs
struct Coefficients
{
double x;
double y;
};

68
struct Coefficients
{
double x;
double y;
};
template <Coefficients coeffs>
struct Filter
{
// stuff :)
};

69
struct Coefficients
{
double x;
double y;
};
template <Coefficients coeffs>
struct Filter
{
// stuff :)
};
constexpr Filter<Coefficients{1, 0.125}> f;

71
CTAD
std::vector v = {1, 2, 3}; // std::vector<int>

72
CTAD
std::tuple t = {42, 0.5, true}; // std::tuple<int, double, bool>

73
CTAD
std::tuple t = {42, 0.5, true}; // std::tuple<int, double, bool>
std::scoped_lock lock(rtmutex); // std::scoped_lock<std::recursive_timed_mutex>

74
C++20 adds:
– CTAD for aggregates
– CTAD for alias templates

75
template <typename T, typename U>
struct aggr_pair
{
T t;
U u;
};
aggr_pair p = {1, true}; // Error: no deduction candidate found
C++17

76
struct aggr_pair
{
T t;
U u;
};
aggr_pair(T, U) -> aggr_pair<T, U>;
aggr_pair p = {1, true}; // OK
C++17

77
struct aggr_pair
{
T t;
U u;
};
aggr_pair(T, U) -> aggr_pair<T, U>;
C++17 C++20
struct aggr_pair
{
T t;
U u;
};

78
template<typename... Bases>
struct overloaded : Bases...
{
using Bases::operator()...;
};
C++17

79
{
};
overloaded(Bases...) -> overloaded<Bases...>;
C++17

80
{
};
overloaded printer = {
[](auto arg) { std::cout << arg << ' '; },
[](double arg) { std::cout << std::fixed << arg << ' '; },
[](const char* arg) { std::cout << std::quoted(arg) << ' '; }
};
C++17

{
};
};
int main()
{
printer("Hello, World!");
}
81
C++17

82
{
};
};
int main()
{
}
C++17

{
};
};
int main()
{
}
83
C++20

84
namespace pmr {
template <class T>
using vector = std::vector<T, std::pmr::polymorphic_allocator<T>>;
}
C++17
std::pmr::vector<int> v{1, 2, 3};

85
namespace pmr {
template <class T>
using vector = std::vector<T, std::pmr::polymorphic_allocator<T>>;
}
C++17 C++20
std::pmr::vector<int> v{1, 2, 3}; std::pmr::vector v{1, 2, 3};

86
1 Initialisation
3 Lambdas
4 Templates
5 constexpr
6 Miscellaneous

87
In C++20, in a constexpr function you can:
– have a try-block
– have an unevaluated asm block
– use a union
– call virtual functions
– dynamic_cast and typeid
– new and delete

88
Daveed Vandevoorde
“C++ Constants”
C++Now 2019 keynote
Louis Dionne
"Compile-time programming and
reflection in C++20 and beyond”
CppCon 2018 talk

89
“running” code at compile time
int square(int i) {
return i * i;
}

90
constexpr int square(int i) {
return i * i;
}
square(3); // compile time
square(x); // runtime

consteval int square(int i) {
return i * i;
}
square(x); // Error - x is not a compile-time constant!
91

92
compile time or runtime?
int square(int i) {
return __magic_fast_square(i); // contains runtime magic
}
square(3); // runtime, fast magic
square(x); // runtime, fast magic

93
return i * i;
}
square(x); // runtime, no fast magic :(

94
if (std::is_constant_evaluated()) {
return i * i;
}
else {
return __magic_fast_square(i);
}
}
square(x); // runtime, fast magic :)

if (std::is_constant_evaluated()) {
return i * i;
}
else {
return __magic_fast_square(i);
}
}
square(x); // runtime, fast magic :)
95

96
1 Initialisation
3 Lambdas
4 Templates
5 constexpr
6 Miscellaneous

97
template <typename Container>
auto findFirstValid(const Container& c) -> Container::iterator
{
return std::find_if(c.begin(), c.end(), [](auto elem){ return elem.is_valid(); });
}

98
auto findFirstValid(const Container& c) -> Container::const_iterator
{
}
// Error: missing 'typename' prior to dependent type name ‘Container::const_iterator'

99
auto findFirstValid(const Container& c) -> Container::const_iterator
{
}
// OK in C++20 :)

101
– [[likely]], [[unlikely]]
New attributes in C++20

102
– [[no_unique_address]]

103
– [[nodiscard]] on constructors

104
– [[nodiscard]] on constructors
– [[nodiscard(“can have a message”)]]

enum class rgba_color_channel {
red,
green,
blue,
alpha
};
105
Using enum

red,
green,
blue,
alpha
};
std::string_view to_string(rgba_color_channel channel) {
switch (channel) {
case rgba_color_channel::red: return "red";
case rgba_color_channel::green: return "green";
case rgba_color_channel::blue: return "blue";
case rgba_color_channel::alpha: return "alpha";
}
}
106
Using enum

107
Using enum
red,
green,
blue,
alpha
};
switch (channel) {
case rgba_color_channel::red: return "red";
case rgba_color_channel::green: return "green";
case rgba_color_channel::blue: return "blue";
case rgba_color_channel::alpha: return "alpha";
}
}

red,
green,
blue,
alpha
};
switch (channel) {
using enum rgba_color_channel;
case red: return "red";
case green: return "green";
case blue: return "blue";
case alpha: return "alpha";
}
}
108
Using enum

enum class Suit {
diamonds,
hearts,
spades,
clubs
};
class Card {
using enum Suit;
Suit suit = spades;
};
109
Using enum

110
Built-in UTF-8 char type
int main() {
const char* str = u8" 🦄 🌈"; // C++17...
}

111
int main() {
const char* str = u8" 🦄 🌈"; // compile error in C++20!
}

int main() {
const char8_t* str = u8" 🦄 🌈";
}
112

C++20 the small things - Timur Doumler

More Related Content

What's hot (20)

Similar to C++20 the small things - Timur Doumler (20)

More from corehard_by (20)

Recently uploaded (20)

C++20 the small things - Timur Doumler