42 silly ways to say "Hello" in modern C++ (Sep 2018)

42 silly ways to say "Hello" in modern C++ (September 2018)
Olve Maudal, Ministry of Silly C++ Code Snippets
1
a 20 minute presentation
September 2018

View Slide

2
This is an attempt to stuff the content of a
two day course into a 20 minute presentation.
There are 436 slides. Fasten your
seatbelts. Enjoy the ride!

View Slide

#include "required_headers.hpp"
void print(const char * begin, const char * end)
{
for (const char * it = begin; it != end; ++it)
std::putchar(*it);
}
int main()
{
const char seq[] = {'H', 'e', 'l', 'l', 'o'};
const char * begin = &seq[0];
const char * end = &seq[std::size(seq)];
print(begin, end);
}
3

View Slide

{
std::putchar(*it);
}
int main()
{
print(begin, end);
}
4
Consider this C++ program demonstrating the
use of iterators.

View Slide

{
std::putchar(*it);
}
int main()
{
print(begin, end);
}
5
We have a sequence of characters.

View Slide

{
std::putchar(*it);
}
int main()
{
print(begin, end);
}
6
We compute the address to the beginning
and to the end of the sequence.

View Slide

{
std::putchar(*it);
}
int main()
{
print(begin, end);
}
7
We pass an iterator pair to our print function.

View Slide

{
std::putchar(*it);
}
int main()
{
print(begin, end);
}
8

View Slide

{
std::putchar(*it);
}
int main()
{
print(begin, end);
}
9

View Slide

{
std::putchar(*it);
}
int main()
{
print(begin, end);
}
10

View Slide

{
std::putchar(*it);
}
int main()
{
print(begin, end);
}
11

View Slide

{
std::putchar(*it);
}
int main()
{
print(begin, end);
}
12
We iterate through every address from begin
to, but not including, the end.

View Slide

{
std::putchar(*it);
}
int main()
{
print(begin, end);
}
13

View Slide

{
std::putchar(*it);
}
int main()
{
print(begin, end);
}
14
For each step, the iterator is dereferenced
and the value is used as an argument to
std::putchar

View Slide

{
std::putchar(*it);
}
int main()
{
print(begin, end);
}
15

View Slide

{
std::putchar(*it);
}
int main()
{
print(begin, end);
}
16
The output of this program is... of course...

View Slide

{
std::putchar(*it);
}
int main()
{
print(begin, end);
}
17
Hello

View Slide

{
std::putchar(*it);
}
int main()
{
print(begin, end);
}
18
Hello
..
1

View Slide

{
std::putchar(*it);
}
int main()
{
print(begin, end);
}
19
Hello
One down, 41 to go.
..
1
iterators

View Slide

{
std::putchar(*it);
}
int main()
{
print(begin, end);
}
20

View Slide

{
std::putchar(*it);
}
int main()
{
print(begin, end);
}
21
In the C++ standard library, there are helper
functions to find the begin and end of a
sequence.

View Slide

{
std::putchar(*it);
}
int main()
{
print(begin, end);
}
22

View Slide

{
std::putchar(*it);
}
int main()
{
const char * begin = std::cbegin(seq);
print(begin, end);
}
23

View Slide

{
std::putchar(*it);
}
int main()
{
print(begin, end);
}
24

View Slide

{
std::putchar(*it);
}
int main()
{
print(begin, end);
}
25

View Slide

{
std::putchar(*it);
}
int main()
{
const char * end = std::cend(seq);
print(begin, end);
}
26

View Slide

{
std::putchar(*it);
}
int main()
{
print(begin, end);
}
27

View Slide

{
std::putchar(*it);
}
int main()
{
print(begin, end);
}
28
Hello
..
2
std::cbegin() and std::cend()

View Slide

{
std::putchar(*it);
}
int main()
{
print(begin, end);
}
29

View Slide

{
std::putchar(*it);
}
int main()
{
print(begin, end);
}
30
These helpers are generic (type independent).
The type of the iterator depends on the type
of the sequence.
We can use type deduction to get the correct
type for our iterators.

View Slide

{
std::putchar(*it);
}
int main()
{
print(begin, end);
}
31

View Slide

{
std::putchar(*it);
}
int main()
{
print(begin, end);
}
32
De r pi ,
I wa t y o t p e s ha n e
"ri t d e" of s i li on...

View Slide

{
std::putchar(*it);
}
int main()
{
decltype(std::cbegin(seq)) begin = std::cbegin(seq);
decltype(std::cend(seq)) end = std::cend(seq);
print(begin, end);
}
33

View Slide

{
std::putchar(*it);
}
int main()
{
auto begin = std::cbegin(seq);
auto end = std::cend(seq);
print(begin, end);
}
34

View Slide

{
std::putchar(*it);
}
int main()
{
print(begin, end);
}
35

View Slide

{
std::putchar(*it);
}
int main()
{
print(begin, end);
}
36

View Slide

{
for (auto it = begin; it != end; ++it)
std::putchar(*it);
}
int main()
{
print(begin, end);
}
37

View Slide

{
std::putchar(*it);
}
int main()
{
print(begin, end);
}
38

View Slide

{
std::putchar(*it);
}
int main()
{
print(begin, end);
}
39
Hello
..
3
type deduction and auto

View Slide

{
std::putchar(*it);
}
int main()
{
print(begin, end);
}
40

View Slide

{
std::putchar(*it);
}
int main()
{
print(begin, end);
}
41

View Slide

{
std::putchar(*it);
}
int main()
{
auto begin{std::cbegin(seq)};
print(begin, end);
}
42

View Slide

{
std::putchar(*it);
}
int main()
{
print(begin, end);
}
43

View Slide

{
std::putchar(*it);
}
int main()
{
auto end{std::cend(seq)};
print(begin, end);
}
44

View Slide

{
std::putchar(*it);
}
int main()
{
print(begin, end);
}
45

View Slide

{
for (auto it{begin}; it != end; ++it)
std::putchar(*it);
}
int main()
{
print(begin, end);
}
46

View Slide

{
std::putchar(*it);
}
int main()
{
print(begin, end);
}
47

View Slide

{
std::putchar(*it);
}
int main()
{
const char seq[]{'H', 'e', 'l', 'l', 'o'};
print(begin, end);
}
48

View Slide

{
std::putchar(*it);
}
int main()
{
print(begin, end);
}
49

View Slide

{
std::putchar(*it);
}
int main()
{
print(begin, end);
}
50
Many consider {}-initialization (aka brace
initializers) to be superior. They give some
extra type checking and other features.
(but looks quite ugly, IMHO)

View Slide

{
std::putchar(*it);
}
int main()
{
print(begin, end);
}
51

View Slide

{
std::putchar(*it);
}
int main()
{
print(begin, end);
}
52
Hello
..
4
{} initialization

View Slide

{
std::putchar(*it);
}
int main()
{
print(begin, end);
}
53
Let's clean up a bit...

View Slide

{
std::putchar(*it);
}
int main()
{
print(begin, end);
}
54

View Slide

{
std::putchar(*it);
}
int main()
{
print(std::cbegin(seq), end);
}
55

View Slide

{
std::putchar(*it);
}
int main()
{
print(std::cbegin(seq), end);
}
56

View Slide

{
std::putchar(*it);
}
int main()
{
print(std::cbegin(seq), std::cend(seq));
}
57

View Slide

{
std::putchar(*it);
}
int main()
{
}
58

View Slide

{
std::putchar(*it);
}
int main()
{
}
59

View Slide

{
std::putchar(*it);
}
int main()
{
}
60

View Slide

{
std::putchar(*it);
}
int main()
{
}
61
This is a typical imperative for-loop. It is also
common to use the declarative std::for_each
algorithm for simple loops like this.

View Slide

{
std::for_each(begin, end, std::putchar);
}
int main()
{
}
62

View Slide

{
}
int main()
{
}
63

View Slide

{
}
int main()
{
}
64

View Slide

{
}
int main()
{
}
65
Hello
..
5
std::for_each algorithm

View Slide

{
}
int main()
{
}
66

View Slide

{
}
int main()
{
}
67
Passing iterator pairs is used all over in C++,
in particular in the C++ standard library.
We may also use a container...

View Slide

{
}
int main()
{
}
68

View Slide

{
}
int main()
{
}
69

View Slide

template
struct MyCharSeq
{
const char * begin() const { return &data_[0]; }
const char * end() const { return &data_[N]; }
char data_[N];
};
{
}
int main()
{
}
70

View Slide

template
struct MyCharSeq
{
char data_[N];
};
{
}
int main()
{
}
71

View Slide

template
struct MyCharSeq
{
char data_[N];
};
{
}
int main()
{
MyCharSeq<5> seq{'H', 'e', 'l', 'l', 'o'};
}
72

View Slide

template
struct MyCharSeq
{
char data_[N];
};
{
}
int main()
{
}
73
... and now we can pass a const ref

View Slide

template
struct MyCharSeq
{
char data_[N];
};
{
}
int main()
{
}
74

View Slide

template
struct MyCharSeq
{
char data_[N];
};
void print(const MyCharSeq<5> & seq)
{
std::for_each(std::cbegin(seq), std::cend(seq), std::putchar);
}
int main()
{
print(seq);
}
75

View Slide

template
struct MyCharSeq
{
char data_[N];
};
{
}
int main()
{
print(seq);
}
76

View Slide

template
struct MyCharSeq
{
char data_[N];
};
{
}
int main()
{
print(seq);
}
77
Hello
..
6
user-defined container
pass by const ref

View Slide

template
struct MyCharSeq
{
char data_[N];
};
{
}
int main()
{
print(seq);
}
78

View Slide

template
struct MyCharSeq
{
char data_[N];
};
{
}
int main()
{
print(seq);
}
79
In the C++ standard library there are many
useful containers defined already. For
example, std::array...

View Slide

template
struct MyCharSeq
{
char data_[N];
};
{
}
int main()
{
print(seq);
}
80

View Slide

void print(const std::array & seq)
{
}
int main()
{
std::array seq{'H', 'e', 'l', 'l', 'o'};
print(seq);
}
81

View Slide

{
}
int main()
{
print(seq);
}
82

View Slide

{
}
int main()
{
print(seq);
}
83

View Slide

{
}
int main()
{
print(seq);
}
84

View Slide

{
}
int main()
{
print(seq);
}
85
Hello
..
7
std::array

View Slide

{
}
int main()
{
print(seq);
}
86

View Slide

{
}
int main()
{
print(seq);
}
87
... and std::vector

View Slide

void print(const std::vector & seq)
{
}
int main()
{
std::vector seq{'H', 'e', 'l', 'l', 'o'};
print(seq);
}
88

View Slide

{
}
int main()
{
print(seq);
}
89

View Slide

{
}
int main()
{
print(seq);
}
90
Hello
..
8
std::vector

View Slide

{
}
int main()
{
print(seq);
}
91

View Slide

{
}
int main()
{
print(seq);
}
92

View Slide

{
}
int main()
{
std::vector seq{'e', 'l', 'l', 'H', 'o'};
print(seq);
}
93

View Slide

{
}
int main()
{
print(seq);
}
94
Perhaps we need to rearrange the elements
before printing out.

View Slide

{
}
int main()
{
print(seq);
}
95
Then we might want to pass by value so that
we get a copy of the container.

View Slide

void print(std::vector seq)
{
}
int main()
{
print(seq);
}
96

View Slide

{
}
int main()
{
print(seq);
}
97
And now we can sort the elements.

View Slide

{
}
int main()
{
print(seq);
}
98

View Slide

{
}
int main()
{
print(seq);
}
99

View Slide

{
std::sort(std::begin(seq), std::end(seq));
}
int main()
{
print(seq);
}
100

View Slide

{
}
int main()
{
print(seq);
}
101

View Slide

{
}
int main()
{
print(seq);
}
102
Hello
..
9
std::sort
pass by value (copy)

View Slide

{
}
int main()
{
print(seq);
}
103

View Slide

{
}
int main()
{
print(seq);
}
104

View Slide

{
}
int main()
{
std::vector seq{'e', '&', '.', 'l', 'l', '{', 'H', 'o'};
print(seq);
}
105

View Slide

{
}
int main()
{
print(seq);
}
106
Here we have some superfluous punctuation
characters that needs to be filtered out.

View Slide

{
}
int main()
{
print(seq);
}
107

View Slide

{
}
int main()
{
print(seq);
}
108

View Slide

{
seq.erase(std::remove_if(std::begin(seq), std::end(seq), ::ispunct), std::end(seq));
}
int main()
{
print(seq);
}
109

View Slide

{
}
int main()
{
print(seq);
}
110
We apply the erase-remove idiom with
ispunct as a predicate.

View Slide

{
}
int main()
{
print(seq);
}
111

View Slide

{
}
int main()
{
print(seq);
}
112
Hello
..
10
erase-remove idiom

View Slide

{
}
int main()
{
print(seq);
}
113

View Slide

{
}
int main()
{
print(seq);
}
114
At this abstraction level it is easy to discover
optimization opportunities.
Here, it looks like we should filter out the
elements first and *then* sort the container.

View Slide

{
}
int main()
{
print(seq);
}
115

View Slide

{
}
int main()
{
print(seq);
}
116

View Slide

{
}
int main()
{
print(seq);
}
117

View Slide

{
}
int main()
{
print(seq);
}
118
Another, now, obvious optimization is to let
sort and for_each work on the
subsequence after remove_if, making the
erase step obsolete.

View Slide

{
}
int main()
{
print(seq);
}
119

View Slide

{
}
int main()
{
print(seq);
}
120

View Slide

{
}
int main()
{
print(seq);
}
121

View Slide

{
auto newend = std::remove_if(std::begin(seq), std::end(seq), ::ispunct);
seq.erase(newend , std::end(seq));
}
int main()
{
print(seq);
}
122

View Slide

{
seq.erase(newend , std::end(seq));
}
int main()
{
print(seq);
}
123

View Slide

{
seq.erase(newend, std::end(seq));
}
int main()
{
print(seq);
}
124

View Slide

{
}
int main()
{
print(seq);
}
125

View Slide

{
std::sort(std::begin(seq), newend);
}
int main()
{
print(seq);
}
126

View Slide

{
}
int main()
{
print(seq);
}
127

View Slide

{
std::for_each(std::cbegin(seq), std::vector::const_iterator(newend), std::putchar);
}
int main()
{
print(seq);
}
128

View Slide

{
}
int main()
{
print(seq);
}
129

View Slide

{
}
int main()
{
print(seq);
}
130

View Slide

{
}
int main()
{
print(seq);
}
131

View Slide

{
}
int main()
{
print(seq);
}
132

View Slide

{
}
int main()
{
print(seq);
}
133

View Slide

{
}
int main()
{
print(seq);
}
134
Hello
..
11
algorithms and high level optimization

View Slide

{
}
int main()
{
print(seq);
}
135

View Slide

{
}
int main()
{
print(seq);
}
136
As well as values, you can also pass function
objects.
Now we will let the caller provide the
filter predicate.

View Slide

{
}
int main()
{
print(seq);
}
137

View Slide

void print(std::vector seq )
{
}
int main()
{
print(seq );
}
138

View Slide

void print(std::vector seq, std::function filter)
{
}
int main()
{
print(seq, ::ispunct);
}
139

View Slide

{
}
int main()
{
}
140

View Slide

{
auto newend = std::remove_if(std::begin(seq), std::end(seq), filter);
}
int main()
{
}
141

View Slide

{
}
int main()
{
}
142

View Slide

{
}
int main()
{
}
143
Hello
..
12
std::function

View Slide

{
}
int main()
{
}
144

View Slide

{
}
int main()
{
}
145
Now we can pass in quite advanced filters.
Let us create an old-school function object
(aka functor).

View Slide

{
}
int main()
{
}
146

View Slide

{
}
int main()
{
struct MyFilter {
MyFilter(std::set validchars) : validchars_(validchars) {}
bool operator()(char ch) const { return validchars_.find(std::tolower(ch)) == validchars_.end(); }
std::set validchars_;
} myfilter({'h','e','l','o'});
}
147

View Slide

{
}
int main()
{
struct MyFilter {
}
148

View Slide

{
}
int main()
{
struct MyFilter {
print(seq, myfilter);
}
149

View Slide

{
}
int main()
{
struct MyFilter {
}
150
Here we have a filter allowing just 4 letters.

View Slide

{
}
int main()
{
struct MyFilter {
}
151
Notice, the key trick here is to overload the
call operator.

View Slide

{
}
int main()
{
struct MyFilter {
}
152

View Slide

{
}
int main()
{
struct MyFilter {
}
153
Hello
..
13
function objects (aka functors)

View Slide

{
}
int main()
{
struct MyFilter {
}
154

View Slide

{
}
int main()
{
struct MyFilter {
}
155
We can also use lambda expressions to
create function objects.

View Slide

{
}
int main()
{
struct MyFilter {
}
156

View Slide

{
}
int main()
{
struct MyFilter {
}
157

View Slide

{
}
int main()
{
struct MyFilter {
}
158

View Slide

{
}
int main()
{
//struct MyFilter {
// MyFilter(std::set validchars) : validchars_(validchars) {}
// bool operator()(char ch) const { return validchars_.find(std::tolower(ch)) == validchars_.end(); }
// std::set validchars_;
//} myfilter({'h','e','l','o'});
auto myfilter = [vc=std::set{'h','e','l','o'}](char ch) { return vc.find(std::tolower(ch)) == vc.end(); };
}
159

View Slide

{
}
int main()
{
//struct MyFilter {
//} myfilter({'h','e','l','o'});
}
160

View Slide

{
}
int main()
{
//struct MyFilter {
//} myfilter({'h','e','l','o'});
}
161
The lambda is equivalent to our old-school
functor.

View Slide

{
}
int main()
{
//struct MyFilter {
//} myfilter({'h','e','l','o'});
}
162

View Slide

{
}
int main()
{
}
163

View Slide

{
}
int main()
{
}
164

View Slide

{
}
int main()
{
}
165
Hello
..
14
lamda expression and generalized lambda capture

View Slide

{
}
int main()
{
}
166

View Slide

{
}
int main()
{
}
167
Lambdas are often used as simple wrappers
for existing functions.

View Slide

{
}
int main()
{
}
168

View Slide

{
}
int main()
{
auto myfilter = [](char ch) { return !std::isalpha(ch); };
}
169

View Slide

{
}
int main()
{
auto myfilter = [](char ch) { return !std::isalpha(ch); };
}
170

View Slide

{
}
int main()
{
print(seq, [](char ch) { return !std::isalpha(ch); });
}
171

View Slide

{
}
int main()
{
}
172

View Slide

{
}
int main()
{
}
173
Hello
..
15
wrap functions with lambda expressions

View Slide

{
}
int main()
{
}
174

View Slide

{
}
int main()
{
}
175
Let us rewrite print into
something more generic.

View Slide

{
}
int main()
{
}
176

View Slide

{
}
int main()
{
}
177

View Slide

{
}
int main()
{
}
178

View Slide

template
void print(Seq seq, Filter filter)
{
}
int main()
{
}
179

View Slide

template
{
}
int main()
{
}
180

View Slide

template
{
std::for_each(std::cbegin(seq), typename Seq::const_iterator(newend), std::putchar);
}
int main()
{
}
181

View Slide

template
{
}
int main()
{
}
182

View Slide

template
{
}
int main()
{
}
183
typename is needed here to help the compiler
to look for a type, instead of a value.

View Slide

template
{
}
int main()
{
}
184

View Slide

template
{
}
int main()
{
}
185
Hello
..
16
function template and dependent names

View Slide

template
{
}
int main()
{
}
186

View Slide

template
{
}
int main()
{
}
187
Generic code is nice, but often you will
need to specify certain requirements for
the template arguments. Types are
known at compile time, so we can use
type traits and static assert to reason
about template arguments.

View Slide

template
{
}
int main()
{
}
188

View Slide

template
{
}
int main()
{
}
189

View Slide

template
{
static_assert(std::is_integral::value);
static_assert(std::is_invocable::value);
}
int main()
{
}
190

View Slide

template
{
}
int main()
{
}
191

View Slide

template
{
}
int main()
{
}
192
Hello
..
17
type traits
static assert

View Slide

template
{
}
int main()
{
}
193

View Slide

template
{
}
int main()
{
}
194
With enable_if we can take this idea
further and tell the compiler that if certain
requirements are not met, then a particular
template should not even be considered for
instantiation.

View Slide

template
{
}
int main()
{
}
195

View Slide

template typename = std::enable_if_t<
std::is_integral::value &&
std::is_invocable::value> >
{
}
int main()
{
}
196

View Slide

{
}
int main()
{
}
197

View Slide

{
}
int main()
{
}
198

View Slide

{
}
int main()
{
}
199

View Slide

{
}
int main()
{
}
200
Hello
..
18
std::enable_if

View Slide

{
}
int main()
{
}
201

View Slide

{
}
int main()
{
}
202
C++20 will probably get Concepts, here is
approximately how it is supposed to work.

View Slide

{
}
int main()
{
}
203

View Slide

template
concept bool MySeqConcept() {
// TODO: also check that sequence is sortable
return std::is_integral::value;
}
template
concept bool MyFilterConcept() {
return std::is_invocable::value;
}
{
}
int main()
{
}
204

View Slide

template
}
template
}
{
}
int main()
{
}
205

View Slide

template
}
template
}
template requires MySeqConcept() && MyFilterConcept()
{
}
int main()
{
}
206

View Slide

template
}
template
}
{
}
int main()
{
}
207

View Slide

template
}
template
}
{
}
int main()
{
}
208
Hello
..
19
concepts
requires
C++20?

View Slide

template
}
template
}
{
}
int main()
{
}
209

View Slide

template
}
template
}
{
}
int main()
{
}
210
concepts can be used instead of the keyword
typename in the template parameter list.

View Slide

template
}
template
}
{
}
int main()
{
}
211

View Slide

template
}
template
}
template
{
}
int main()
{
}
212

View Slide

template
}
template
}
template
{
}
int main()
{
}
213

View Slide

template
}
template
}
template
{
}
int main()
{
}
214
Hello
..
20
concepts as template parameters
C++20?

View Slide

template
}
template
}
template
{
}
int main()
{
}
215

View Slide

template
}
template
}
template
{
}
int main()
{
}
216
I am now going to show something that probably will not make
it into C++20, and maybe never... However, with the current
version of gcc (8.2.0) it is possible to play with the idea of
using concepts instead of types in a function declaration. (The
effect is that you are really declaring a template.)

View Slide

template
}
template
}
template
{
}
int main()
{
}
217
First I need to make a small change in the
iterator pair for the for_each since the Seq
type will soon be replaced by a concept.

View Slide

template
}
template
}
template
{
}
int main()
{
}
218

View Slide

template
}
template
}
template
{
std::for_each(std::cbegin(seq), typename decltype(seq)::const_iterator(newend), std::putchar);
}
int main()
{
}
219

View Slide

template
}
template
}
template
{
}
int main()
{
}
220

View Slide

template
}
template
}
// template
void print(MySeqConcept seq, MyFilterConcept filter)
{
}
int main()
{
}
221

View Slide

template
}
template
}
// template
{
}
int main()
{
}
222

View Slide

template
}
template
}
{
}
int main()
{
}
223

View Slide

template
}
template
}
{
}
int main()
{
}
224

View Slide

template
}
template
}
{
}
int main()
{
}
225
Now that we are using the concept names in
the function declaration, we can go further
and rename them.

View Slide

template
}
template
}
{
}
int main()
{
}
226

View Slide

template
}
template
}
{
}
int main()
{
}
227

View Slide

template
}
template
}
{
}
int main()
{
}
228

View Slide

template
}
template
}
{
}
int main()
{
}
229

View Slide

template
concept bool Seq() {
}
template
concept bool Filter() {
}
{
}
int main()
{
}
230

View Slide

template
}
template
}
{
}
int main()
{
}
231

View Slide

template
}
template
}
{
}
int main()
{
}
232
Hello
..
21
concepts in function declaration
C++26?

View Slide

template
}
template
}
{
}
int main()
{
}
233

View Slide

template
}
template
}
{
}
int main()
{
}
234
Enough templates and concepts for now.
Let's simplify the code.

View Slide

template
}
template
}
{
}
int main()
{
}
235

View Slide

{
}
int main()
{
}
236

View Slide

{
}
int main()
{
}
237

View Slide

{
auto newend = std::remove_if(std::begin(seq), std::end(seq), [](char ch) { return !std::isalpha(ch); });
}
int main()
{
}
238

View Slide

{
}
int main()
{
}
239

View Slide

{
}
int main()
{
print(seq);
}
240

View Slide

{
}
int main()
{
print(seq);
}
241
For efficiency, we might want to
pass by reference.

View Slide

{
}
int main()
{
print(seq);
}
242

View Slide

void print(std::vector & seq)
{
}
int main()
{
print(seq);
}
243

View Slide

{
}
int main()
{
print(seq);
}
244
The key thing here is the & to avoid a copy
operation. We pass the sequence by a so
called lvalue reference. Since we are not
using the sequence after the call to print, this
might be an acceptable solution.

View Slide

{
}
int main()
{
print(seq);
}
245

View Slide

{
}
int main()
{
print(seq);
}
246
Hello
..
22
pass by lvalue reference

View Slide

{
}
int main()
{
print(seq);
}
247

View Slide

{
}
int main()
{
print(seq);
}
248
It would be nice to express ownership when
passing references like this. Who owns the
content of the object? With rvalue references
and move semantics you can in our example
express transfer of ownership with && and a
std::move.

View Slide

{
}
int main()
{
print(seq);
}
249

View Slide

void print(std::vector && seq)
{
}
int main()
{
print(std::move(seq));
}
250

View Slide

{
}
int main()
{
}
251

View Slide

{
}
int main()
{
}
252
It is important to realize that std::move is
just a cast from lvalue to rvalue.

View Slide

{
}
int main()
{
}
253

View Slide

{
}
int main()
{
}
254
Hello
..
23
pass by rvalue reference
std::move

View Slide

{
}
int main()
{
}
255

View Slide

{
}
int main()
{
}
256
Now we will show how rvalue references can
bind to objects without a name, eg a return
value from a function.

View Slide

{
}
int main()
{
}
257

View Slide

{
}
int main()
{
}
258

View Slide

{
}
std::vector greeting()
{
return std::vector{'e', '&', '.', 'l', 'l', '{', 'H', 'o'};
}
int main()
{
}
259

View Slide

{
}
{
}
int main()
{
}
260

View Slide

{
}
{
}
int main()
{
std::vector seq = greeting();
}
261

View Slide

{
}
{
}
int main()
{
std::vector seq = greeting();
}
262

View Slide

{
}
{
}
int main()
{
print(greeting());
}
263

View Slide

{
}
{
}
int main()
{
print(greeting());
}
264

View Slide

{
}
{
}
int main()
{
print(greeting());
}
265
Due to return value optimization, copy
elision, rvalues and move semantics,
nothing will be copied here. All the elements
(and the ownership) are just moved into the
print function.

View Slide

{
}
{
}
int main()
{
print(greeting());
}
266

View Slide

{
}
{
}
int main()
{
print(greeting());
}
267
Hello
..
24
return value optimization and copy elision

View Slide

{
}
{
}
int main()
{
print(greeting());
}
268

View Slide

{
}
{
}
int main()
{
print(greeting());
}
269
std::vector has a move constructor, so
here pass by value is just moving elements if
we give it an rvalue.

View Slide

{
}
{
}
int main()
{
print(greeting());
}
270

View Slide

{
}
{
}
int main()
{
print(greeting());
}
271

View Slide

{
}
{
}
int main()
{
print(greeting());
}
272

View Slide

{
}
{
}
int main()
{
print(greeting());
}
273
Hello
..
25
std::vector move constructor

View Slide

{
}
{
}
int main()
{
print(greeting());
}
274

View Slide

{
}
{
}
int main()
{
print(greeting());
}
275
When planning this presentation, I promised
myself that I would show structural binding
and if statement with initialization. Although
a small detour, this is the time to show it.

View Slide

{
}
{
}
int main()
{
print(greeting());
}
276

View Slide

{
}
auto greeting()
{
return std::tuple,int>({'e', '&', '.', 'l', 'l', '{', 'H', 'o'}, 42);
}
int main()
{
auto [str, answer] = greeting();
if (answer == 42)
print(str);
}
277

View Slide

{
}
auto greeting()
{
}
int main()
{
auto [str, answer] = greeting();
if (answer == 42)
print(str);
}
278

View Slide

{
}
auto greeting()
{
}
int main()
{
if (auto [str, answer] = greeting(); answer == 42)
print(str);
}
279

View Slide

{
}
auto greeting()
{
}
int main()
{
print(str);
}
280

View Slide

{
}
auto greeting()
{
}
int main()
{
print(str);
}
281
Hello
..
26
if statement with initializer
std::tuple
structural binding

View Slide

{
}
auto greeting()
{
}
int main()
{
print(str);
}
282

View Slide

{
}
auto greeting()
{
}
int main()
{
print(str);
}
283
Now for something completely different!

View Slide

{
}
auto greeting()
{
}
int main()
{
print(str);
}
284

View Slide

std::size_t print(std::vector seq)
{
std::for_each(std::crbegin(seq), std::crend(seq), std::putchar);
return std::size(seq);
}
int main()
{
std::vector seq{'o', 'l', 'l', 'e', 'H'};
print(seq);
}
285

View Slide

{
}
int main()
{
print(seq);
}
286

View Slide

{
}
int main()
{
print(seq);
}
287
Notice that the elements are in the wrong order.

View Slide

{
}
int main()
{
print(seq);
}
288

View Slide

{
}
int main()
{
print(seq);
}
289
No problem, just apply reverse iterators to get it right.

View Slide

{
}
int main()
{
print(seq);
}
290

View Slide

{
}
int main()
{
print(seq);
}
291
Hello
..
27
reverse iterators

View Slide

{
}
int main()
{
print(seq);
}
292

View Slide

{
}
int main()
{
print(seq);
}
293
Let's write our very own putchar and put it in
our very own namespace.

View Slide

{
}
int main()
{
print(seq);
}
294

View Slide

namespace my {
void putchar(char ch)
{
std::cout << ch << std::flush;
}
}
{
std::for_each(std::crbegin(seq), std::crend(seq), my::putchar);
}
int main()
{
print(seq);
}
295

View Slide

namespace my {
{
}
}
{
}
int main()
{
print(seq);
}
296

View Slide

namespace my {
{
}
}
{
}
int main()
{
print(seq);
}
297
Hello
..
28
namespace and std::flush

View Slide

namespace my {
{
}
}
{
}
int main()
{
print(seq);
}
298

View Slide

namespace my {
{
}
}
{
}
int main()
{
print(seq);
}
299
Let's introduce a type writer effect by adding
a small pause before printing each character.

View Slide

namespace my {
{
}
}
{
}
int main()
{
print(seq);
}
300

View Slide

namespace my {
{
std::this_thread::sleep_for(std::chrono::milliseconds(500));
}
}
{
}
int main()
{
print(seq);
}
301

View Slide

namespace my {
{
}
}
{
}
int main()
{
print(seq);
}
302

View Slide

namespace my {
{
}
}
{
}
int main()
{
print(seq);
}
303

View Slide

namespace my {
{
}
}
{
}
int main()
{
print(seq);
}
304
H

View Slide

namespace my {
{
}
}
{
}
int main()
{
print(seq);
}
305
He

View Slide

namespace my {
{
}
}
{
}
int main()
{
print(seq);
}
306
Hel

View Slide

namespace my {
{
}
}
{
}
int main()
{
print(seq);
}
307
Hell

View Slide

namespace my {
{
}
}
{
}
int main()
{
print(seq);
}
308
Hello

View Slide

namespace my {
{
}
}
{
}
int main()
{
print(seq);
}
309
Hello
..
29
chrono and sleep_for

View Slide

namespace my {
{
}
}
{
}
int main()
{
print(seq);
}
310

View Slide

namespace my {
{
}
}
{
}
int main()
{
print(seq);
}
311
We will soon show how to run code
asynchronously. But first we show an
alternative way to invoke a function.

View Slide

namespace my {
{
}
}
{
}
int main()
{
print(seq);
}
312

View Slide

namespace my {
{
}
}
{
}
int main()
{
std::invoke(print, seq);
}
313

View Slide

namespace my {
{
}
}
{
}
int main()
{
auto n = std::invoke(print, seq);
std::cout << n;
}
314

View Slide

namespace my {
{
}
}
{
}
int main()
{
std::cout << n;
}
315

View Slide

namespace my {
{
}
}
{
}
int main()
{
std::cout << n;
}
316
Hello5
..
30
std::invoke

View Slide

namespace my {
{
}
}
{
}
int main()
{
std::cout << n;
}
317

View Slide

namespace my {
{
}
}
{
}
int main()
{
std::cout << n;
}
318
Now we can replace std::invoke with
std::async

View Slide

namespace my {
{
}
}
{
}
int main()
{
std::cout << n;
}
319

View Slide

namespace my {
{
}
}
{
}
int main()
{
auto f = std::async(print, seq);
auto n = f.get();
std::cout << n;
}
320

View Slide

namespace my {
{
}
}
{
}
int main()
{
auto n = f.get();
std::cout << n;
}
321

View Slide

namespace my {
{
}
}
{
}
int main()
{
auto n = f.get();
std::cout << n;
}
322
std::async returns a future that holds a
value that we can retrieve later. Notice how
invoking and getting the result is now two
separate statements, this allow us to
something while it is executing.

View Slide

namespace my {
{
}
}
{
}
int main()
{
auto n = f.get();
std::cout << n;
}
323

View Slide

namespace my {
{
}
}
{
}
int main()
{
auto n = f.get();
std::cout << n;
}
324

View Slide

namespace my {
{
}
}
{
}
int main()
{
for (int i = 10; i; --i)
my::putchar('.');
auto n = f.get();
std::cout << n;
}
325

View Slide

namespace my {
{
}
}
{
}
int main()
{
for (int i = 10; i; --i)
my::putchar('.');
auto n = f.get();
std::cout << n;
}
326

View Slide

namespace my {
{
}
}
{
}
int main()
{
for (int i = 10; i; --i)
my::putchar('.');
auto n = f.get();
std::cout << n;
}
327
.H.el.l..o.....5
..
31
this what I often get on my
machine...
std::async
promise and future

View Slide

namespace my {
{
}
}
{
}
int main()
{
for (int i = 10; i; --i)
my::putchar('.');
auto n = f.get();
std::cout << n;
}
328

View Slide

namespace my {
{
}
}
{
}
int main()
{
for (int i = 10; i; --i)
my::putchar('.');
auto n = f.get();
std::cout << n;
}
329
The default launch policy depends on your
compiler/runtime. By explicitly specify the
launch policy you can for example defer
execution until you call the get() function.
This can be useful, in particular when
debugging.

View Slide

namespace my {
{
}
}
{
}
int main()
{
for (int i = 10; i; --i)
my::putchar('.');
auto n = f.get();
std::cout << n;
}
330

View Slide

namespace my {
{
}
}
{
}
int main()
{
auto f = std::async(std::launch::deferred, print, seq);
for (int i = 10; i; --i)
my::putchar('.');
auto n = f.get();
std::cout << n;
}
331

View Slide

namespace my {
{
}
}
{
}
int main()
{
for (int i = 10; i; --i)
my::putchar('.');
auto n = f.get();
std::cout << n;
}
332

View Slide

namespace my {
{
}
}
{
}
int main()
{
for (int i = 10; i; --i)
my::putchar('.');
auto n = f.get();
std::cout << n;
}
333
..........Hello5
..
32
deferred launch policy

View Slide

namespace my {
{
}
}
{
}
int main()
{
for (int i = 10; i; --i)
my::putchar('.');
auto n = f.get();
std::cout << n;
}
334

View Slide

namespace my {
{
}
}
{
}
int main()
{
for (int i = 10; i; --i)
my::putchar('.');
auto n = f.get();
std::cout << n;
}
335
Or you can specify that you want threads to
be created and started.

View Slide

namespace my {
{
}
}
{
}
int main()
{
for (int i = 10; i; --i)
my::putchar('.');
auto n = f.get();
std::cout << n;
}
336

View Slide

namespace my {
{
}
}
{
}
int main()
{
auto f = std::async(std::launch::async, print, seq);
for (int i = 10; i; --i)
my::putchar('.');
auto n = f.get();
std::cout << n;
}
337

View Slide

namespace my {
{
}
}
{
}
int main()
{
for (int i = 10; i; --i)
my::putchar('.');
auto n = f.get();
std::cout << n;
}
338

View Slide

namespace my {
{
}
}
{
}
int main()
{
for (int i = 10; i; --i)
my::putchar('.');
auto n = f.get();
std::cout << n;
}
339
.H.el.l..o.....5
..
33
async launch policy

View Slide

namespace my {
{
}
}
{
}
int main()
{
for (int i = 10; i; --i)
my::putchar('.');
auto n = f.get();
std::cout << n;
}
340

View Slide

namespace my {
{
}
}
{
}
int main()
{
for (int i = 10; i; --i)
my::putchar('.');
auto n = f.get();
std::cout << n;
}
341
Ok, I just can not resist... let's have some fun
with overloading the multiplication operator
and create a repeat function. (Don't do this in
your codebase...)

View Slide

namespace my {
{
}
}
{
}
int main()
{
for (int i = 10; i; --i)
my::putchar('.');
auto n = f.get();
std::cout << n;
}
342

View Slide

namespace my {
{
}
}
{
}
template
void operator*(int n, Func f)
{
while (n--)
f();
}
int main()
{
for (int i = 10; i; --i)
my::putchar('.');
auto n = f.get();
std::cout << n;
}
343

View Slide

namespace my {
{
}
}
{
}
template
{
while (n--)
f();
}
int main()
{
for (int i = 10; i; --i)
my::putchar('.');
auto n = f.get();
std::cout << n;
}
344

View Slide

namespace my {
{
}
}
{
}
template
{
while (n--)
f();
}
int main()
{
10 * []{ my::putchar('.'); };
auto n = f.get();
std::cout << n;
}
345

View Slide

namespace my {
{
}
}
{
}
template
{
while (n--)
f();
}
int main()
{
10 * []{ my::putchar('.'); };
auto n = f.get();
std::cout << n;
}
346

View Slide

namespace my {
{
}
}
{
}
template
{
while (n--)
f();
}
int main()
{
10 * []{ my::putchar('.'); };
auto n = f.get();
std::cout << n;
}
347
.H.el.l..o.....5
..
34
silly operator overload (don't do this)

View Slide

namespace my {
{
}
}
{
}
template
{
while (n--)
f();
}
int main()
{
10 * []{ my::putchar('.'); };
auto n = f.get();
std::cout << n;
}
348

View Slide

namespace my {
{
}
}
{
}
template
{
while (n--)
f();
}
int main()
{
10 * []{ my::putchar('.'); };
auto n = f.get();
std::cout << n;
}
349
I am now going to show user-defined literals,
but first we clean up the code.

View Slide

namespace my {
{
}
}
{
}
template
{
while (n--)
f();
}
int main()
{
10 * []{ my::putchar('.'); };
auto n = f.get();
std::cout << n;
}
350

View Slide

namespace my {
{
}
}
{
}
int main()
{
auto n = f.get();
std::cout << n;
}
351

View Slide

namespace my {
{
}
}
{
}
int main()
{
auto n = f.get();
std::cout << n;
}
352

View Slide

namespace my {
{
}
}
{
}
int main()
{
print(seq);
}
353

View Slide

namespace my {
{
}
}
{
}
int main()
{
print(seq);
}
354

View Slide

namespace my {
{
}
}
{
}
int main()
{
print(seq);
}
355
Here we go, user-defined literals!

View Slide

namespace my {
{
}
}
{
}
int main()
{
print(seq);
}
356

View Slide

auto operator"" _ms(unsigned long long n)
{
return std::chrono::milliseconds(n);
}
namespace my {
{
}
}
{
}
int main()
{
print(seq);
}
357

View Slide

{
}
namespace my {
{
}
}
{
}
int main()
{
print(seq);
}
358

View Slide

{
}
namespace my {
{
std::this_thread::sleep_for(500_ms);
}
}
{
}
int main()
{
print(seq);
}
359

View Slide

{
}
namespace my {
{
}
}
{
}
int main()
{
print(seq);
}
360

View Slide

{
}
namespace my {
{
}
}
{
}
int main()
{
print(seq);
}
361

View Slide

{
}
namespace my {
{
}
}
{
}
int main()
{
print(seq);
}
362
H

View Slide

{
}
namespace my {
{
}
}
{
}
int main()
{
print(seq);
}
363
He

View Slide

{
}
namespace my {
{
}
}
{
}
int main()
{
print(seq);
}
364
Hel

View Slide

{
}
namespace my {
{
}
}
{
}
int main()
{
print(seq);
}
365
Hell

View Slide

{
}
namespace my {
{
}
}
{
}
int main()
{
print(seq);
}
366
Hello

View Slide

{
}
namespace my {
{
}
}
{
}
int main()
{
print(seq);
}
367
Hello
..
35
user-defined literals (UDL)

View Slide

{
}
namespace my {
{
}
}
{
}
int main()
{
print(seq);
}
368

View Slide

{
}
namespace my {
{
}
}
{
}
int main()
{
print(seq);
}
369
The C++ standard library already comes with
a handful of useful user-defined literals.

View Slide

{
}
namespace my {
{
}
}
{
}
int main()
{
print(seq);
}
370

View Slide

using namespace std::chrono_literals;
namespace my {
{
std::this_thread::sleep_for(500ms);
}
}
{
}
int main()
{
print(seq);
}
371

View Slide

namespace my {
{
}
}
{
}
int main()
{
print(seq);
}
372

View Slide

namespace my {
{
}
}
{
}
int main()
{
print(seq);
}
373
Hello
..
36
std::chrono_literals

View Slide

namespace my {
{
}
}
{
}
int main()
{
print(seq);
}
374

View Slide

namespace my {
{
}
}
{
}
int main()
{
print(seq);
}
375

View Slide

namespace my {
{
std::this_thread::sleep_for(500000000ns);
}
}
{
}
int main()
{
print(seq);
}
376

View Slide

namespace my {
{
}
}
{
}
int main()
{
print(seq);
}
377

View Slide

namespace my {
{
}
}
{
}
int main()
{
print(seq);
}
378
Even nanoseconds.

View Slide

namespace my {
{
}
}
{
}
int main()
{
print(seq);
}
379
Even nanoseconds.
Phew, this is hard to read...

View Slide

namespace my {
{
}
}
{
}
int main()
{
print(seq);
}
380

View Slide

namespace my {
{
}
}
{
}
int main()
{
print(seq);
}
381

View Slide

namespace my {
{
std::this_thread::sleep_for(500'000'000ns);
}
}
{
}
int main()
{
print(seq);
}
382

View Slide

namespace my {
{
}
}
{
}
int main()
{
print(seq);
}
383
Better?

View Slide

namespace my {
{
}
}
{
}
int main()
{
print(seq);
}
384

View Slide

namespace my {
{
}
}
{
}
int main()
{
print(seq);
}
385
Hello
..
37
digits separator

View Slide

namespace my {
{
}
}
{
}
int main()
{
print(seq);
}
386

View Slide

namespace my {
{
}
}
{
}
int main()
{
print(seq);
}
387
Now for something completely different...

View Slide

namespace my {
{
}
}
{
}
int main()
{
print(seq);
}
388

View Slide

int main()
{
std::string s = "................Hello..........";
std::size_t bi = std::min(s.find_first_not_of('.'), std::size(s));
std::size_t ei = std::min(s.find_first_of('.',bi), std::size(s));
std::for_each(&s[bi], &s[ei], std::putchar);
}
389

View Slide

int main()
{
}
390

View Slide

int main()
{
}
391
Hello
..
38
std::string

View Slide

int main()
{
}
392

View Slide

int main()
{
}
393
After finding the beginning and the end, we
can create a view into the string...

View Slide

int main()
{
}
394

View Slide

int main()
{
std::size_t len = ei - bi;
std::string_view sv(&s[bi], len);
}
395

View Slide

int main()
{
}
396

View Slide

int main()
{
std::for_each(std::cbegin(sv), std::cend(sv), std::putchar);
}
397

View Slide

int main()
{
}
398

View Slide

int main()
{
}
399
And since this is just a trivial pass from begin
to end, we can also use the very cute
range-for.

View Slide

int main()
{
}
400

View Slide

int main()
{
}
401

View Slide

int main()
{
for (char c : sv)
std::putchar(c);
}
402

View Slide

int main()
{
for (char c : sv)
std::putchar(c);
}
403

View Slide

int main()
{
for (char c : sv)
std::putchar(c);
}
404
Hello
..
39
std::string_view
range-for

View Slide

int main()
{
for (char c : sv)
std::putchar(c);
}
405

View Slide

int main()
{
for (char c : sv)
std::putchar(c);
}
406
The C++ standard library also comes with
predefined string literals.

View Slide

int main()
{
for (char c : sv)
std::putchar(c);
}
407

View Slide

using namespace std::literals;
int main()
{
for (char c : sv)
std::putchar(c);
}
408

View Slide

int main()
{
for (char c : sv)
std::putchar(c);
}
409

View Slide

int main()
{
std::string s = "................Hello.........."s;
for (char c : sv)
std::putchar(c);
}
410

View Slide

int main()
{
std::string s = "................Hello.........."s;
for (char c : sv)
std::putchar(c);
}
411

View Slide

int main()
{
auto s = "................Hello.........."s;
for (char c : sv)
std::putchar(c);
}
412

View Slide

int main()
{
auto s = "................Hello.........."s;
for (char c : sv)
std::putchar(c);
}
413

View Slide

int main()
{
auto s = "................Hello.........."s;
for (char c : sv)
std::putchar(c);
}
414
There is also a string_view literal...

View Slide

int main()
{
auto s = "................Hello.........."s;
for (char c : sv)
std::putchar(c);
}
415

View Slide

int main()
{
auto s = "................Hello.........."sv;
for (char c : sv)
std::putchar(c);
}
416

View Slide

int main()
{
auto s = "................Hello.........."sv;
for (char c : sv)
std::putchar(c);
}
417

View Slide

int main()
{
auto s = "................Hello.........."sv;
for (char c : sv)
std::putchar(c);
}
418
Hello
..
40
string literals

View Slide

int main()
{
auto s = "................Hello.........."sv;
for (char c : sv)
std::putchar(c);
}
419

View Slide

int main()
{
auto s = "................Hello.........."sv;
for (char c : sv)
std::putchar(c);
}
420
Notice that most of this could be computed
in compile time. Indeed, with constexpr you
can force the compiler to compute stuff if
possible.

View Slide

int main()
{
auto s = "................Hello.........."sv;
for (char c : sv)
std::putchar(c);
}
421

View Slide

int main()
{
constexpr auto s = "................Hello.........."sv;
constexpr std::size_t bi = std::min(s.find_first_not_of('.'), std::size(s));
constexpr std::size_t ei = std::min(s.find_first_of('.',bi), std::size(s));
constexpr std::size_t len = ei - bi;
constexpr std::string_view sv(&s[bi], len);
for (char c : sv)
std::putchar(c);
}
422

View Slide

int main()
{
for (char c : sv)
std::putchar(c);
}
423

View Slide

int main()
{
for (char c : sv)
std::putchar(c);
}
424
Hello
..
41
constexpr

View Slide

int main()
{
for (char c : sv)
std::putchar(c);
}
425

View Slide

int main()
{
for (char c : sv)
std::putchar(c);
}
426
And last, but not least...

View Slide

int main()
{
for (char c : sv)
std::putchar(c);
}
427

View Slide

#include
int main()
{
std::cout << "Hello\n";
}
428

View Slide

#include
int main()
{
}
429
It is possible to print out "Hello" just like this.

View Slide

#include
int main()
{
}
430

View Slide

#include
int main()
{
}
431
Hello
..
42
just "Hello"

View Slide

432
!

View Slide

433
1. iterators
2. std::cbegin() / std::cend()
3. type deduction and auto
4. {} initialization (aka brace initialization)
5. std::for_each
6. user-defined container and pass by const ref
7. std::array
8. std::vector
9. std::sort and pass by value (copy)
10. erase-remove idiom
11. algorithms and high level optimization
12. std::function
13. function objects (aka functors)
14. lambda expression and generalized lambda capture
15. wrap functions with lambda expressions
16. function template and dependent names
17. type traits and static assert
18. enable_if
19. concepts and requires (C++20?)
20. concepts as template parameters (C++20?)
21. concepts in function declaration (C++23?)
22. pass by lvalue reference
23. pass by rvalue reference and std::move
24. return value optimization and copy elision
25. the std::vector move constructor
26. std::tuple, structural binding and if statement with initializer
27. reverse iterators
28. namespace and my::putchar
29. chrono and sleep_for
30. std::invoke
31. async, future and promise
32. std::launch::deferred
33. std::launch::async
34. silly operator overload (don't do this)
35. user-defined literals
36. std::chrono_literals
37. digits separator
38. std::string
39. std::string_view and range-for
40. string literals
41. constexpr
42. just "Hello"

View Slide

434

View Slide

435
Still here? OK, one more then...

View Slide

namespace my {
void putchar(char ch, long delay)
{
std::this_thread::sleep_for(std::chrono::milliseconds(delay));
}
}
{
std::vector> futures(std::size(seq));
for (char ch : seq)
futures.emplace_back(std::async(my::putchar, ch, ch));
}
int main()
{
std::vector seq{'e', 'l', 'H', 'o', 'l'};
print(seq);
}
436
Hello
..
sleep sort

View Slide

42 silly ways to say "Hello" in modern C++ (Sep 2018)

42 silly ways to say "Hello" in modern C++ (Sep 2018)

Olve Maudal

More Decks by Olve Maudal

Other Decks in Programming

Featured

Transcript