C++ 11/14

Alexandre Hamez
alexandre.hamez@gmail.com
C++ 11/14

C++11/14
3
• Nouveau langage
• Possiblement des gains de performance juste en recompilant
• rvalues references, move semantics
• Quelques incompatibilités avec le standard précédent, mais bien
souvent pour plus de sécurité ou de performances
• ex. un destructeur ne peut plus lever d’exception par défaut
(ce qui était déjà une mauvaise chose)
• ex. règles de conversion plus strictes dans l’initialisation
d’agrégats int tab[] = {1.0}; // compilation error

4
ranged-base for loop
auto
constexpr
static_assert
rvalues references
enum class
uniform initialization
noexcept
variadic templates
relaxed POD deﬁnition
nullptr
unrestricted unions
lambdas
decltype
trailing return type
extern template
final
override
>>
user-deﬁned literals
alignas
alignof

5
shared_ptr
unordered_map
mutex
thread
atomic
regex
unique_ptr
bind
reference_wrapper
unordered_set
tuple
chrono
random
forward
forward_list
function
enable_if
result_of
move
array
...

Compilateurs
6
• Visual Studio 2013 (incomplet)
‣ http://msdn.microsoft.com/en-us/library/hh567368.aspx
‣ plus gros manque : constexpr
• Clang ≥ 3.3
‣ http://clang.llvm.org/cxx_status.html
• GCC ≥ 4.8
‣ https://gcc.gnu.org/projects/cxx0x.html

Boucles simpliﬁées
9
#include <iostream>
#include <vector>
int main()
{
std::vector<int> v;
v.push_back(1);
v.push_back(2);
for ( std::vector<int>::const_iterator cit = v.begin()
; cit != v.end(); ++cit)
{
std::cout << *cit << ',';
}
}
À l’ancienne : utilisation des itérateurs

10
#include <iostream>
#include <vector>
int main()
{
std::vector<int> v;
v.push_back(1);
v.push_back(2);
for (int i : v)
{
std::cout << i << ',';
}
}
Syntaxe simpliﬁée

10
#include <iostream>
#include <vector>
int main()
{
std::vector<int> v;
v.push_back(1);
v.push_back(2);
for (int i : v)
{
std::cout << i << ',';
}
}
Syntaxe simpliﬁée
écriture naturelle

11
{
typedef std::vector<int>::const_iterator cit_t;
for ( cit_t __begin = v.begin(), __end = v.end()
; __begin != __end; ++__begin)
{
int i = *__begin;
std::cout << i << ',';
}
}
sous le capot :

12
std::map<int, int> m;
m.insert(std::make_pair(1,1));
for (std::map<int, int>::value_type key_value : m)
{
std::cout << key_value.first << ',' << key_value.second;
}
n’importe quel conteneur fournissant des itérateurs

12
for (std::map<int, int>::value_type key_value : m)
{
std::cout << key_value.first << ',' << key_value.second;
}
n’importe quel conteneur fournissant des itérateurs
pas de ‘&’ →copie

13
const int tab[] = {1,2,3};
for (int x : tab)
{
std::cout << x << 'n';
}
tableaux C

14
• En résumé, fonctionne pour
‣ les tableaux C
‣ tous les types qui fournissent
- les fonctions membres begin(), end()
- les fonctions libres begin(type), end(type)

auto
15
#include <map>
int main()
{
for (std::pair<int, int>& key_value : m)
{
// do something with key_value
}
}
où est le problème?

auto
16
#include <map>
int main()
{
for (std::pair<const int, int>& key_value : m)
{
// ...
}
}

auto
16
#include <map>
int main()
{
for (std::pair<const int, int>& key_value : m)
{
// ...
}
}
la clef dans une std::map est
constante

auto
17
#include <map>
int main()
{
for (auto& key_value : m)
{
// ...
}
}

auto
17
#include <map>
int main()
{
{
// ...
}
}
le compilateur fait le travail pour
nous : plus d’erreur possible

18
auto
#include <map>
int main()
{
auto m = std::map<int, int>();
{
}
}

18
auto
#include <map>
int main()
{
{
}
}
pour toute variable

19
for (const auto& key_value : m)
{
key_value.second = 2; // compilation error
}
auto
auto utilise les règles de déduction des templates

20
#include <vector>
std::vector<int> fun()
{
// return something
}
int main()
{
const auto container = fun();
for (const auto& value : container)
{
// do something
}
}
auto
facilite la maintenance de code

21
#include <deque>
std::deque<int> fun()
{
// return something
}
int main()
{
{
// do something
}
}
auto

21
#include <deque>
{
// return something
}
int main()
{
{
// do something
}
}
fun() change
auto

21
#include <deque>
{
// return something
}
int main()
{
{
// do something
}
}
main() ne change pas!
fun() change
auto

22
• permet d’adopter un style de programmation fonctionnelle
‣ Scala : val x = fun()
‣ C++ : const auto x = fun();
• auto utilise les règles de déduction des templates
‣ sauf pour le cas des listes d’initialisation (initializer_list)
auto

23
const auto x = foo();
void* _ = x;
error: cannot initialize a variable of type 'void *' with an lvalue of type
'TYPE'
void* _ = x;
^ ~
1 error generated.
auto
connaître le type déduit (tout compilateur)

Initialisation uniformisée
24
struct foo {};
struct bar
{
bar(foo){}
};
int main()
{
// function declaration or variable definition?
bar b(foo());
}
“most vexing parse”
• deﬁne variable b of type bar with an instance of foo; or
• declare function b which returns a bar and takes a function with no parameter and which
returns a foo

25
struct foo {};
struct bar
{
bar(foo){}
};
int main()
{
// add parentheses to declare a variable
bar b((foo()));
}
“most vexing parse”

26
struct foo {};
struct bar
{
bar(foo){}
};
int main()
{
// brace initializer
bar b{foo{}};
// better
auto b1 = bar{foo{}};
}
solution : utiliser la syntaxe pour initialiser les agrégats : {}

27
struct foo
{
int i_;
foo(int i) : i_(i) {}
};
struct bar
{
int i_;
};
int main()
{
const auto f = foo{42};
const auto b = bar{42};
}
pour construire un objet

28
class foo
{
int i_;
public:
foo(int i) : i_(i) {}
};
struct bar
{
int i_;
};
int main()
{
const auto f = foo{42};
}
pour construire struct ou class

29
struct foo
{
int i;
};
foo fun()
{
return {42};
}
int main()
{
const auto f = fun();
}
concision : on peut omettre le type de retour

29
struct foo
{
int i;
};
foo fun()
{
return {42};
}
int main()
{
const auto f = fun();
}
concision : on peut omettre le type de retour
pas de type explicite

30
#include <map>
int main()
{
auto m = std::map<int,int>{};
// old style
m.insert(std::make_pair(1, 2));
// new style
m.insert({1, 2});
}
exemple : insertion dans un conteneur associatif

31
double a, b, c;
int x{a + b + c};
int y(a + b + c);
int z = a + b + c;
ne compile pas :
perte de précision
OK (mais mal)
idem
plus de sécurité

32
• Que choisir?
• “{}”
‣ résistant au most vexing parse
‣ empêche la perte de précision
‣ utilisation plus cohérente
• “()”
‣ ne casse pas les habitudes
‣ pas de confusion avec initializer_list (à suivre…)

initializer_list
33
#include <iostream>
#include <vector>
int main()
{
const auto vec = std::vector<int>{1,2,3};
for (const auto& x : vec)
{
std::cout << x;
}
}
même syntaxe que pour initialiser les agrégats

initializer_list
33
#include <iostream>
#include <vector>
int main()
{
const auto vec = std::vector<int>{1,2,3};
{
std::cout << x;
}
}
déclaration “naturelle”
même syntaxe que pour initialiser les agrégats

initializer_list
34
• C++11 déﬁnit un nouveau type
‣ std::initializer_list<T>
‣ #include <initializer_list>
• Utilise la même syntaxe d'initialisation des tableaux C
• {1,2,3}
• Le contenu de la liste est copié

initializer_list
35
#include <initializer_list>
int main()
{
// deduced to std::initializer_list<int>
const auto list = {1,2,2};
for (auto x : list)
{
// ...
}
}
exception : auto + {} initializer_list
auto utilise la déduction des templates

initializer_list
35
int main()
{
// deduced to std::initializer_list<int>
const auto list = {1,2,2};
for (auto x : list)
{
// ...
}
}
ne pas oublier!
exception : auto + {} initializer_list
auto utilise la déduction des templates

initializer_list
36
void foo(std::initializer_list<int> list)
{
for (auto i : list) {}
}
foo({1,2,3});
initializer_list en paramètre

initializer_list
36
void foo(std::initializer_list<int> list)
{
for (auto i : list) {}
}
foo({1,2,3});
passage par valeur
initializer_list en paramètre

initializer_list
37
struct bar
{
bar(std::initializer_list<int> list);
};
const auto b = bar{1,2,3};
can be used to construct objects

initializer_list
38
void foo(int i, std::initializer_list<int> li)
{
std::cout << i << " : ";
for (auto x : li) std::cout << x << ",";
}
foo(42, {3,2,3,4});
utilisable avec d’autres arguments

initializer_list
39
for (auto x : {1,2,3,4})
{
std::cout << x << ',';
}
utilisable dans une boucle simpliﬁée

initializer_list
40
#include <iostream>
struct bar
{
bar(std::initializer_list<int> list){std::cout << "listn";}
bar(int) {std::cout << "intn";}
};
int main()
{
}
qu’afﬁche le code suivant?

initializer_list
41
#include <iostream>
#include <vector>
int main ()
{
const auto v1 = std::vector<int>{2};
std::cout << v1.size();
const auto v2 = std::vector<int>(2);
std::cout << v2.size();
}
mais… qu’afﬁche le code suivant?

initializer_list
42
• Permet de
‣ faciliter l’écriture des tests unitaires
‣ offrir une API élégante au code client
‣ …
const auto v1 = std::vector<int>{1,2,3};
auto v2 = std::vector<int>{};
v2.reserve(3);
v2.push_back(1);
v2.push_back(2);
v2.push_back(3);
vs

initializer_list
42
• Permet de
‣ faciliter l’écriture des tests unitaires
‣ offrir une API élégante au code client
‣ …
const auto v1 = std::vector<int>{1,2,3};
auto v2 = std::vector<int>{};
v2.reserve(3);
v2.push_back(1);
v2.push_back(2);
v2.push_back(3);
vs
bonus : plus d’immutabilité

User-deﬁned literals
43
unsigned long x0 = 0ul;
long x1 = 0l;
// etc.
C++03 : il est possible de sufﬁxer un littéral
pour y appliquer des caractéristiques

44
long double
operator"" _deg (long double x)
{
return x * 3.141592/180;
}
const auto x = 90.0_deg;
pour convertir une valeur

44
long double
operator"" _deg (long double x)
{
return x * 3.141592/180;
}
const auto x = 90.0_deg;
ne pas oublier “_”
pour convertir une valeur

45
struct foo
{
const unsigned long long x_;
foo(unsigned long long x)
: x_(x)
{}
};
foo
operator"" _foo (unsigned long long n)
{
return {n};
}
const auto f = 123_foo;
pour construire un objet

46
void
operator"" _print(const char* str, std::size_t)
{
std::cout << str;
}
"C++11 rocks!"_print;
à partir de chaînes de caractères

47
struct point
{
//???
};
// Yaye!
const auto p = 3_x + 5_y;
comment obtenir cette construction?

48
struct x_type{unsigned long long value;};
struct y_type{unsigned long long value;};
x_type operator"" _x(unsigned long long value) {return {value};}
y_type operator"" _y(unsigned long long value) {return {value};}
struct point
{
unsigned long long x_, y_;
private:
point(const x_type& x, const y_type& y)
: x_(x.value), y_(y.value)
{}
friend point operator+(const x_type&, const y_type&);
};
point operator+(const x_type& x, const y_type& y)
{return {x, y};};
// later...
const auto p = 3_x + 5_y;

String literals
49
const auto utf8 = u8"UTF-8 string. u2705n”;
std::cout << utf8;
const auto utf16 = u8"UTF-16 string.n”;
std::wcout << utf16;
UTF-8 string. ✅
UTF-16 string.
Gestion UTF-8, UTF-16 et UTF-32

Binary literals
50
const auto b = 0b00101010;
std::cout << b; // 42
C++14 uniquement

Séparateur ‘
51
const auto big_value = 64'000'000'000'000'000;
facilite la lecture des grandes constantes
const auto b = 0b0010'1010;

Raw string literals
52
const auto raw = R"(@
tLook Ma, no tabs!
some
text
)";
const auto escaped = "@n"
"somen"
"textn";
int
main()
{
std::cout << raw;
std::cout << "--------------n";
std::cout << escaped;
}
@
tLook Ma, no tabs!
some
text
--------------
@
some
text

enum class
53
int main()
{
enum e{pink, white, orange, brown};
const auto white = 0ul;
}
error: redefinition of 'white' as different kind of symbol
             ^
note: previous definition is here
               ^
enum C++03 : pollution de l’espace de nommage

enum class
53
int main()
{
}
ne compile pas
error: redefinition of 'white' as different kind of symbol
             ^
note: previous definition is here
               ^
enum C++03 : pollution de l’espace de nommage

enum class
54
enum e {pink, white, orange, brown};
if (pink < 99.3)
{
// ...
}
enum C++03 : conversion implicite dangereuse

enum class
54
enum e {pink, white, orange, brown};
if (pink < 99.3)
{
// ...
}
enum C++03 : conversion implicite dangereuse
compile, mais est-ce
vraiment une bonne chose?

enum class
55
int main()
{
enum class e{pink, white, orange, brown};
const auto e0 = e::white;
}
enum class créé une nouvelle portée

enum class
55
int main()
{
const auto e0 = e::white;
}
enum class créé une nouvelle portée
accès à la portée de e

enum class
56
// use std::underlying_type<e>::type to find enum’s type
type par défaut sous-jacent : int

enum class
57
enum class e : unsigned long
{pink = 0, white, orange, brown = 0xFFFFFFFFFFFFFFFF};
// use std::underlying_type<e>::type to find enum’s type
changer le type sous-jacent

enum class
58
• C++03 : il n’y a pas de type par défaut pour énumération
‣ on est donc obligé de la mettre dans les headers
‣ recompilation en cascade s’il faut rajouter un champ
• C++11 : on peut faire une pré-déclaration
‣ déﬁnition dans une unité de compilation séparée
‣ pas de recompilation en cascade

nullptr
59
void f(int) {std::cout << "f(int)";}
void f(void*){std::cout << "f(void*)";}
f(0);
f(NULL);
error: call to 'f' is ambiguous
  f(NULL);
  ^
note: candidate function
     ^
f(int)
f(int)
clang/gcc Visual Studio

nullptr
60
f(0);
f(nullptr);
f(int)
f(void*)
moins d’ambiguité

nullptr
61
const auto x = f();
if (x == 0)
{
// ...
}
plus de clarté
const auto x = f();
if (x == nullptr)
{
// ...
}
vs

nullptr
61
const auto x = f();
if (x == 0)
{
// ...
}
plus de clarté
const auto x = f();
if (x == nullptr)
{
// ...
}
vs intention plus claire

nullptr
62
type de nullptr
void f(void*) {std::cout << "f(void*)";}
void f(std::nullptr_t) {std::cout << "f(nullptr_t)";}
f(nullptr);

alignas
63
alignas(16) int a;
alignas(32768) int b;
std::cout << &a;
std::cout << &b;
0x7fff58d2ffe0
0x7fff58d28000
contrôler l’alignement mémoire

alignof
64
std::cout << alignof(int);
std::cout << alignof(long);
std::cout << alignof(char);
std::cout << alignof(char*);
connaître l’alignement mémoire (d’un type)
4
8
1
8

Classes
• Délégation de constructeurs
• Héritage des constructeurs des classes de base
• Initialisation directe des attributs
• Contrôle de l’héritage
• Contrôle explicite des méthodes supprimées
65

Classes
66
délégation de constructeurs (1)
struct foo
{
const int x_;
foo(int x)
: x_{x}
{}
foo()
: foo{42}
{}
};

Classes
66
struct foo
{
const int x_;
foo(int x)
: x_{x}
{}
foo()
: foo{42}
{}
};
délégation

Classes
67
struct foo
{
const int x_;
foo(int x = 42)
: x_{x}
{}
};
on pourrait utiliser les arguments par défaut
problème : dans l’interface de la classe

Classes
68
héritage des constructeurs (1) : C++03
struct base
{
const int x_;
base(int x)
: x_(x)
{}
};
struct foo : public base
{
foo(int x)
: base(x)
{}
};

Classes
68
struct base
{
const int x_;
base(int x)
: x_(x)
{}
};
{
foo(int x)
: base(x)
{}
};
appel explicite

Classes
69
struct base
{
const int x_;
base(int x)
: x_(x)
{}
};
{
using base::base;
};

Classes
69
struct base
{
const int x_;
base(int x)
: x_(x)
{}
};
{
using base::base;
};
hérite de tous les constructeurs
de base

Classes
70
initialisation directe des attributs
struct foo
{
const int x_ = 33;
foo(int x)
: x_(x)
{}
foo()
{}
};

Classes
70
initialisation directe des attributs
struct foo
{
const int x_ = 33;
foo(int x)
: x_(x)
{}
foo()
{}
};
valeur par défaut utilisée par tous
les constructeurs

Classes
71
contrôle de l’héritage avec final
struct foo final {};
struct bar : foo {};

Classes
71
contrôle de l’héritage avec final
struct foo final {};
ne compile pas
error: base 'foo' is marked 'final'
^

Classes
72
contrôle de l’héritage avec override (1)
struct base
{
virtual void operator()(float x) const
{std::cout << "base " << x;}
};
struct derived : public base
{
virtual void operator()(int x) const
{std::cout << "derived " << x;}
};
const auto d = derived{};
auto x = 33.3;
d(x);

Classes
72
struct base
{
virtual void operator()(float x) const
{std::cout << "base " << x;}
};
{
{std::cout << "derived " << x;}
};
const auto d = derived{};
auto x = 33.3;
d(x);
afﬁchage?

Classes
73
struct base
{
virtual void operator()(float x) const;
};
{
virtual void operator()(int x) const override;
};

Classes
73
struct base
{
virtual void operator()(float x) const;
};
{
};
error: 'operator()' marked 'override' but does not override any member functions
^

Classes
74
contrôle des fonctions membres avec default / delete (1)
struct non_copyable
{
non_copyable(){}
private:
non_copyable(const non_copyable&);
non_copyable& operator=(const non_copyable&);
};
int main()
{
const auto nc = non_copyable{};
}
error: calling a private constructor of class 'non_copyable'
^

Classes
75
struct non_copyable
{
non_copyable() = default;
non_copyable(const non_copyable&) = delete;
non_copyable& operator=(const non_copyable&) = delete;
};
int main()
{
}
error: call to deleted constructor of 'const non_copyable'
             ^    ~~~~~~~~~~~~~~
note: 'non_copyable' has been explicitly marked deleted here
  non_copyable(const non_copyable&) = delete;

Classes
76
struct base
{
virtual void operator()(int x) const;
};
{
};
int main()
{
const auto override = 0ul;
const auto final = 0ul;
}

Classes
76
struct base
{
virtual void operator()(int x) const;
};
{
};
int main()
{
const auto override = 0ul;
const auto final = 0ul;
}
pas des mots-clefs

delete
77
void foo(int){};
void foo(long) = delete;
void foo(double) = delete;
foo(42); // OK
foo(42l); // ERROR
foo(42.0); // ERROR
permet aussi d’empêcher certaines surcharges
error: call to deleted function 'foo'
  foo(42l);
  ^~~
note: candidate function has been explicitly deleted
void foo(long) = delete;
     ^
void foo(int){};
     ^
note: candidate function has been explicitly deleted
void foo(double) = delete;
     ^

Rvalues references
• Ajout majeur au C++
• Travailler explicitement avec les temporaires
• Éviter des copies inutiles
‣ move semantics
• Perfect forwarding
‣ construire en place
‣ généricité améliorée
‣ …
78

Rvalues references
• lvalues
‣ un objet qui occupe une place identiﬁable en mémoire
- qui a une adresse
• rvalues
‣ un objet qui n’occupe pas une place identiﬁable en mémoire
- qui n’a pas d’adresse : temporaire
79
lvalue = rvalue
lvalue = lvalue
rvalue = lvalue
int x = 42
int x = y
42 = ...

Rvalues references
80
int foo() {return 2;}
int main()
{
foo() = 2;
}
error: lvalue required as left operand of assignment
foo() = 2;
^

Rvalues references
81
struct foo {
foo() {
std::cout << “foo()n”;
}
foo(const foo&) {
std::cout << "foo(const foo&)n”;
}
foo& operator=(const foo&) {
std::cout << "operator=(const foo&)n”;
return *this;
}
};
foo bar() {return {};}
const auto f0 = foo{};
auto f1 = bar();
f1 = bar();
interlude : copy elision

Rvalues references
81
struct foo {
foo() {
std::cout << “foo()n”;
}
foo(const foo&) {
std::cout << "foo(const foo&)n”;
}
foo& operator=(const foo&) {
std::cout << "operator=(const foo&)n”;
return *this;
}
};
foo bar() {return {};}
const auto f0 = foo{};
auto f1 = bar();
f1 = bar();
interlude : copy elision
?

Rvalues references
82
comment éviter la copie? (1)
foo* bar() {return new foo{};}
auto f1 = bar();
// later...
f1 = bar();
• Retour par pointeur
‣ Coût de l’allocation
‣ Qui est responsable du pointeur?

Rvalues references
83
comment éviter la copie? (2)
void bar(foo*);
auto f = foo{};
bar(&f);
• Passage par pointeur ou référence en paramètre
• Quid des factories?

Rvalues references
84
comment modiﬁer un temporaire?
void bar(foo&);
//...
auto f = foo{};
bar(f1);
bar(foo{});
utile pour un objet fonction avec état (cache, etc.)

Rvalues references
84
comment modiﬁer un temporaire?
void bar(foo&);
//...
auto f = foo{};
bar(f1);
bar(foo{}); ne compile pas
utile pour un objet fonction avec état (cache, etc.)

Rvalues references
85
struct foo{int x;};
void bar(foo&& f)
{
std::cout << f.x << 'n';
}
//...
bar(foo{42});

Rvalues references
85
struct foo{int x;};
void bar(foo&& f)
{
}
//...
bar(foo{42});
foo&& : rvalue reference

Rvalues references
85
struct foo{int x;};
void bar(foo&& f)
{
}
//...
bar(foo{42});
foo{42} : rvalue expression

Rvalues references
85
struct foo{int x;};
void bar(foo&& f)
{
}
//...
bar(foo{42});
f : lvalue expression
on peut prendre l’adresse de f

Rvalues references
85
struct foo{int x;};
void bar(foo&& f)
{
}
//...
bar(foo{42});
f : lvalue expression
on peut prendre l’adresse de f
le passage en paramètre “nomme” le temporaire
celui-ci devient une lvalue : on peut prendre son adresse sur la pile

Rvalues references
86
une rvalue reference n’accepte que des rvalue expressions
struct foo{int x;};
void bar(foo&& f)
{
}
//...
auto f = foo{42};
bar(f);

Rvalues references
86
une rvalue reference n’accepte que des rvalue expressions
struct foo{int x;};
void bar(foo&& f)
{
}
//...
auto f = foo{42};
bar(f);
erreur : f n’est pas une rvalue expression

Rvalues references
87
ref-qualiﬁers
struct foo
{
void operator()() const
&&
{
std::cout << "&&n";
}
&
{
std::cout << "&n";
}
};
//...
const auto f = foo{};
f();
foo{}();

Rvalues references
87
ref-qualiﬁers
struct foo
{
&&
{
std::cout << "&&n";
}
&
{
std::cout << "&n";
}
};
//...
f();
foo{}();
en tant que
rvalue
en tant que
lvalue

Move semantics
• Permet d’exprimer le “déplacement” d’une ressource
• Permet d’exprimer le changement de propriétaire d’une entité
non copiable
‣ mutex, ﬁchier, …
• Utilisation des rvalues references
• Utilisation de std::move()
‣ instruction au compilateur
‣ ne génère aucun code
88

Ressource2Ressource1
Move semantics
89
A B

X Ressource1
Move semantics
89
A B

Move semantics
90
struct foo {
some_type* ressource;
foo& operator=(const foo& rhs) {
// destroy this->ressource
// clone rhs.ressource
// attach this cloned ressource to this->ressource
}
};
auto f1 = foo{};
auto f2 = foo{};
// later...
f2 = f1;
copie

Move semantics
90
struct foo {
foo& operator=(const foo& rhs) {
// clone rhs.ressource
// attach this cloned ressource to this->ressource
}
};
auto f1 = foo{};
auto f2 = foo{};
// later...
f2 = f1;
copie
O(n)

Move semantics
91
auto f1 = foo{};
//...
auto f2 = std::move(f1);
// now f1 is “invalid”
transfert de ressource (1)
move() transforme une lvalue expression en rvalue expression

Move semantics
92
struct foo {
foo& operator=(foo&& rhs) {
// copy rhs.ressource pointer to this->ressource
}
};
auto f1 = foo{};
auto f2 = foo{};
//...
f2 = std::move(f1);

Move semantics
92
struct foo {
}
};
auto f1 = foo{};
auto f2 = foo{};
//...
f2 = std::move(f1);
O(1)

Move semantics
92
struct foo {
}
};
auto f1 = foo{};
auto f2 = foo{};
//...
f2 = std::move(f1);
O(1) mais pas toujours…

Move semantics
93
struct foo
{
foo() = default;
foo(const foo&) = default;
foo(foo&&) = delete;
};
int main()
{
}

Move semantics
93
struct foo
{
foo() = default;
foo(const foo&) = default;
};
int main()
{
}
ne compile pas

Move semantics
94
struct foo {};
foo return_by_value()
{
return f;
}
void take_by_value(foo) {}
auto f1 = foo{};
auto f2 = f1;
auto f3 = std::move(f1);
take_by_value(f2);
take_by_value(std::move(f2));
auto f4 = return_by_value();
f1 = return_by_value();
quelles sont
les opérations
appelées?

Move semantics
95
transfert de propriété
struct foo
{
some_type ressource;
// forbid copy
foo(const foo&) = delete;
foo& operator=(const foo&) = delete;
foo(foo&& rhs) noexcept
{
// 1. acquire ownership of rhs.ressource
// 2. free rhs from its ownership
}
foo& operator=(foo&&) noexcept
{
// 1. release ownership of current ressource
// 2. acquire ownership of rhs.ressource
// 3. free rhs from its ownership
}
};

Move semantics
96
struct foo;
foo bar()
{
auto f = foo{};
// later...
return std::move(f);
}
std::move en retour d’une fonction

Move semantics
96
struct foo;
foo bar()
{
auto f = foo{};
// later...
return std::move(f);
}
mauvaise idée
std::move en retour d’une fonction

Move semantics
97
const rvalue references?
void bar(const foo&& f); // what for if we can't move f?
void bar(const foo&); // read only
réellement utile pour interdire tout usage des rvalues
struct foo
{
foo() {};
foo(const foo&&) = delete;
};
// later...
const foo f0;
foo f1(std::move(f0));
void bar(const foo&& f); // what for if we can't move f?
void bar(const foo&); // read only

Move semantics
98
struct foo;
foo f1;
foo f2;
std::swap(f1, f2);
C++03 vs C++11
foo()
foo()
foo(foo&&)
operator=(foo&&)
operator=(foo&&)
foo()
foo()
foo(const foo&)
operator=(const foo&)
operator=(const foo&)
C++03 C++11

decltype
99
permet de connaître le type d’une expression
int* foo();
using ty0 = decltype(foo);
print_type<ty0>();
using ty1 = decltype(foo());
print_type<ty1>();
void print_type() [T = int *()]
void print_type() [T = int *]

100
auto foo() -> int
{
return 42;
}
std::cout << foo();
type de retour après les paramètres

101
template <typename T1, typename T2>
???
add(const T1& x, const T2& y)
{
return x + y;
}
si le type de retour dépend des paramètres
auto
-> decltype(x+y)
{
return x + y;
}

102
double (*get_fun2(bool arg))(double)
{
if (arg) return std::cos;
else return std::sin;
}
plus de lisibilité
auto get_fun(bool arg)
-> double(*)(double)
{
}
vs

103
C++14 : on peut se passer du type de retour
auto
-> decltype(x+y)
{
return x + y;
}

104
C++14 : on peut se passer du type de retour
mais pas toujours…
auto get_fun(bool arg)
{
}
error: cannot deduce return type 'auto' from returned value of type '<overloaded
function type>'

105
lambdas
struct print1
{
void operator()(int x) const
{
}
};
void print2(int x)
{
}
const auto v = {1,2,3};
std::for_each(begin(v), end(v), print1{});
std::for_each(begin(v), end(v), print2);
programmation fonctionnelle :
objets fonctions et fonctions en argument

lambdas
106
std::for_each( begin(v), end(v)
, [](int x){std::cout << x << ‘n';}
);
const auto print =
[](int x){std::cout << x << 'n';};
std::for_each(begin(v), end(v), print);
par l’exemple
const auto fun = []{return 42;};
const auto x = fun();

lambdas
107
const auto print = [](int x){std::cout << x;};
print_type<decltype(print)>();
void print_type() [with T = const main()::<lambda(int)>]
type d’un lambda
il n’y pas de type pour les lambdas en tant que tel
auto est quasi-obligatoire si on veut stocker un lambda
ou presque…

lambdas
108
anatomie d’un lambda
[capture](params) -> ret_type {body}
comment “capturer”
l’environnement corps de la fonction
peut-être omis
type de retour si nécessaire

lambdas
109
spéciﬁcation du type de retour (1)
struct foo {};
struct bar : public foo {};
struct baz : public foo {};
const auto foo_maker = [](bool value)
{
if (value) return new bar{};
else return new baz{};
};
const auto ptr = foo_maker(true);
error: return type 'baz *' must match previous return type 'bar *' when lambda
expression has unspecified explicit return type
^

lambdas
110
struct foo {};
const auto foo_maker = [](bool value) -> foo*
{
};

lambdas
110
struct foo {};
const auto foo_maker = [](bool value) -> foo*
{
};
type de retour

lambdas
111
capture de l’environnement (1)
[] ne capture rien
[&] tout par référence
[=] tout par valeur
[this] capture this
[=,&b]
copie tout, mais
reférence b
[&a, b] référence a, copie b
environnement = toutes les variables de la portée englobante

lambdas
111
[] ne capture rien
[&] tout par référence
[=] tout par valeur
[this] capture this
[=,&b]
copie tout, mais
reférence b
[&a, b] référence a, copie b
environnement en
“lecture seule”
environnement = toutes les variables de la portée englobante
const auto x = 42u;
[]{std::cout << x;}(); // OK
auto x = 40u;
[]{x += 2;}(); // ERROR

struct foo
{
int x_;
int bar(int y)
{
return [this](int y)
{return x_ + y;}
(y);
}
};
std::cout << foo{40}.bar(2);
lambdas
112
auto x = 40u;
[&x](int y){x += y;}(2);
std::cout << x;
auto a = 40u;
[&](int b){a += b;}(2);
std::cout << x;

auto x = 44u;
[=]{x -= 2;}();
lambdas
113
error: cannot assign to a variable captured by copy in a non-mutable lambda
[=]{x -= 2;}();
~ ^
auto x = 44u;
[=]() mutable {x -= 2;}();

auto x = 44u;
[=]{x -= 2;}();
lambdas
113
error: cannot assign to a variable captured by copy in a non-mutable lambda
[=]{x -= 2;}();
~ ^
auto x = 44u;
[=]() mutable {x -= 2;}();
obligatoire

lambdas
114
“fermeture” équivalente à un objet fonction (1)
struct closure
{
double& capture_;
int operator()(int x, int& y) const
{
return (x + y) * capture_;
}
closure() = delete;
closure& operator=(const closure&) = delete;
closure(const closure& ) = default;
closure(closure&& ) = default;
~closure() = default;
};
auto fun0 = [&d](int x, int& y){return (x + y) * d;};

lambdas
114
struct closure
{
double& capture_;
int operator()(int x, int& y) const
{
return (x + y) * capture_;
}
closure() = delete;
closure& operator=(const closure&) = delete;
closure(const closure& ) = default;
closure(closure&& ) = default;
~closure() = default;
};
d’où le mutable

lambdas
115
auto d = 0.0;
auto fun1 = fun0; // OK
fun1 = fun0; // KO no copy operator
using ty = decltype(fun0);
auto fun2 = ty{}; // KO no default ctor

lambdas
116
en paramètre d’un template
template <typename F, typename T>
void apply(T x)
{
F{}(x);
}
auto fun = [](int x){x += 1;};
apply<decltype(fun)>(0);

lambdas
117
attention aux références invalides
auto mk_fun()
-> std::function<void (int&)>
{
auto i = 33u;
return [&](int& j){j += i;};
}
int main()
{
auto j = 2;
const auto fun = mk_fun();
fun(j); // Doomed to failure
}

lambdas
117
auto mk_fun()
{
auto i = 33u;
}
int main()
{
auto j = 2;
}
portée locale à mk_fun

lambdas
117
auto mk_fun()
{
auto i = 33u;
}
int main()
{
auto j = 2;
}
portée locale à mk_fun
lecture de i locale à
mk_fun

lambdas
118
C++14 : paramètres génériques
const auto add
= [](const auto& x, const auto& y){return x + y;};
add(1,2);
add(std::string{"1"}, std::string{"2"});

lambdas
119
au service de l’immutabilité
const auto read_only = [&]
{
std::vector<int> res;
// super-complex initialisation
return res
}();
read_only.push_back(3); // nope, won’t do
auto read_only = std::vector<int>{};
// super-complex initialisation
// ...later
// damned, still mutable!
read_only.push_back(3);

noexcept
• C++03
‣ il faut lister dans la signature d’une fonction les exceptions qu’elle
peut lever (throw (…))
‣ difﬁcile à maintenir
‣ pas ou peu d’aide des compilateurs
• C++11
‣ seule alternative : une fonction peut ou ne peut pas lever
d’exception
‣ avantage majeur : le compilateur a plus d’opportunités
d’optimisations
120

noexcept
121
void foo()
noexcept
{
// shall not throw any exception
}
struct foo
{
void
operator()() const
noexcept
{
}
};
sur fonctions libres ou membres

noexcept
122
opportunités d’optimisation
auto vec = std::vector<foo>{};
vec.push_back(f);
• Si vec doit agrandir son stockage interne
‣ C++03 : recopie
- si une exception est lancée pendant la copie, vec original n’est pas
modiﬁé (strong guarantee)
‣ C++11 : strong guarantee à tenir
- move si foo(foo&&) noexcept
- copie sinon

noexcept
123
noexcept conditionnel (1)
void bar()
noexcept
{
}
void foo()
noexcept(noexcept(bar()))
{
bar();
}

noexcept
124
noexcept conditionnel (2)
struct bar
{
void operator()(int) noexcept {}
};
struct baz
{
void operator()(int){}
};
template <typename Fun>
void foo(int x)
noexcept(noexcept(Fun{}(x)))
{
Fun{}(x);
}
foo<bar>(33);
foo<baz>(42);

noexcept
125
noexcept appliqué aux lambdas
const auto lambda
= [](int x) noexcept {return x + 40;};
std::cout << lambda(2);

• Destructeurs, operator delete et operator delete[] : noexcept par
défaut
• C’est une afﬁrmation forte
‣ déclarer une fonction noexcept, puis plus tard enlever cette spéciﬁcation
peut casser le code client
• Important pour
‣ foo(foo&&)
‣ foo& operator=(foo&&)
‣ swap(foo&, foo&)
‣ fonctions de calcul (sans allocations dynamiques)?
‣ …?
126
noexcept

constexpr
127
• const : spéciﬁer des interfaces
- foo(const std::vector<int>&);
• constexpr : spéciﬁer ce qui est utilisable dans des expressions
constantes (et donc possiblement évaluées à la compilation)
- tout ce qui est marqué constexpr doit pouvoir produire
un résultat constant
• Applicable aux objets et aux fonctions
Visual Studio 2013

constexpr
128
auto sz = 3;
// ERROR: sz's value not known at compilation
constexpr auto sz1 = sz;
auto array1 = std::array<int, sz>{};
// OK: 10 is a compile-time constant
constexpr auto sz2 = 10;
// OK: sz2 is constexpr
auto array2 = std::array<int, sz2>{};
objets (1)

constexpr
129
const auto sz = 3;
// OK: sz's value is known at compilation
// OK: sz's value is known at compilation
auto x = 3;
const auto sz = x;
objets (2)

constexpr
130
fonctions
constexpr
int foo(int a)
{
return a + 1;
}
constexpr auto x = foo(42);
auto runtime_value = 0u;
std::cin >> runtime_value;
auto y = foo(runtime_value);
fonction expression constante expression non-constante
constexpr ✓ ✓
non-constexpr ✕ ✓

constexpr
131
C++11
seulement une expression autorisée
constexpr int fac(int x)
{
return x <= 1
? 1
: x * fac(x-1);
}
constexpr int fac(int x)
{
auto res = 1;
for (auto i = 1; i <= x; ++i)
{
res *= i;
}
return res;
}
C++14
plusieurs instructions autorisées

constexpr
132
classes
struct foo
{
int data;
constexpr foo(int d) : data(d) {}
constexpr int operator()() const
{return data + 1;}
constexpr operator int() const
{return data;}
};
auto f0 = foo{42};
constexpr auto f1 = foo{33};
auto i0 = f0();
constexpr auto i1 = f1();
constexpr auto i2 = static_cast<int>(f1);
auto i3 = static_cast<int>(f1);

constexpr
132
classes
struct foo
{
int data;
constexpr foo(int d) : data(d) {}
constexpr int operator()() const
{return data + 1;}
constexpr operator int() const
{return data;}
};
auto f0 = foo{42};
constexpr auto f1 = foo{33};
auto i0 = f0();
constexpr auto i1 = f1();
constexpr auto i2 = static_cast<int>(f1);
auto i3 = static_cast<int>(f1);
implicite en C++11
à mettre en C++14

constexpr
133
unsigned int f(unsigned int n)
{
return n <= 1
? 1
: n * f(n-1);
}
int main()
{
return f(5);
}
constexpr
{
return n <= 1
? 1
: n * f(n-1);
}
int main()
{
return f(5);
}
en pratique (clang)…

constexpr
133
{
return n <= 1
? 1
: n * f(n-1);
}
int main()
{
return f(5);
}
constexpr
{
return n <= 1
? 1
: n * f(n-1);
}
int main()
{
return f(5);
}
pushq %rbp
movq %rsp, %rbp
movl $0x78, %eax
popq %rbp
retq

constexpr
133
{
return n <= 1
? 1
: n * f(n-1);
}
int main()
{
return f(5);
}
constexpr
{
return n <= 1
? 1
: n * f(n-1);
}
int main()
{
return f(5);
}
pushq %rbp
movq %rsp, %rbp
movl $0x78, %eax
popq %rbp
retq
movdqa %xmm0, %xmm1
movhlps %xmm1, %xmm1
pshufd $0x31, %xmm0, %xmm2
pmuludq %xmm1, %xmm0
shufps $-0x78, %xmm1, %xmm0
pshufd $-0x28, %xmm0, %xmm0
shufps $-0x78, %xmm2, %xmm1
pshufd $-0x28, %xmm1, %xmm0
movd %xmm0, %eax
cmpl %edx, %r8d
je 0x100000f5d
nopw %cs:(%rax,%rax)
imull %edi, %eax
leal -0x1(%rdi), %ecx
cmpl $0x1, %ecx
movl %ecx, %edi
ja 0x100000f50
popq %rbp
retq
nop
pushq %rbp
movq %rsp, %rbp
movl $0x78, %eax
popq %rbp
retq

constexpr
133
{
return n <= 1
? 1
: n * f(n-1);
}
int main()
{
return f(5);
}
constexpr
{
return n <= 1
? 1
: n * f(n-1);
}
int main()
{
return f(5);
}
pushq %rbp
movq %rsp, %rbp
movl $0x78, %eax
popq %rbp
retq
pushq %rbp
movq %rsp, %rbp
movl $0x1, %eax
cmpl $0x2, %edi
jb 0x100000f5d
leal -0x1(%rdi), %r8d
movl %r8d, %ecx

constexpr
133
{
return n <= 1
? 1
: n * f(n-1);
}
int main()
{
return f(5);
}
constexpr
{
return n <= 1
? 1
: n * f(n-1);
}
int main()
{
return f(5);
}
Évaluation à l’exécution Évaluation à la compilation

static_assert
134
#include <type_traits>
template <typename T>
constexpr bool
is_power_of_two(T x)
{
static_assert( std::is_integral<T>::value
and std::is_unsigned<T>::value
, "Integral and unsigned type expected");
return x and ((x & (x-1)) == 0);
}
int main()
{
is_power_of_two(-2);
}
faire échouer la compilation sur un message clair
error: static_assert failed "Integral and unsigned type expected"
static_assert( std::is_integral<T>::value and std::is_unsigned<T>::value
^ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

static_assert
134
#include <type_traits>
constexpr bool
is_power_of_two(T x)
{
static_assert( std::is_integral<T>::value
and std::is_unsigned<T>::value
, "Integral and unsigned type expected");
return x and ((x & (x-1)) == 0);
}
int main()
{
is_power_of_two(-2);
}
faire échouer la compilation sur un message clair
error: static_assert failed "Integral and unsigned type expected"
static_assert( std::is_integral<T>::value and std::is_unsigned<T>::value
^ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
expression constante requise

Généricité
136
struct foo_vector
{
foo* data;
unsigned int sz;
void push_back(const foo& x)
{
data[sz++] = x;
}
};
une nécessité pour les structures de données…
auto int_vec = int_vector{};
auto foo_vec = foo_vector{};
int_vec.push_back(1);
foo_vec.push_back(foo{});
struct int_vector
{
int* data;
unsigned int sz;
void push_back(const int& x)
{
data[sz++] = x;
}
};

Généricité
137
struct int_vector
{
int* data;
unsigned int sz;
void push_back(const int& x)
{
data[sz++] = x;
}
};
struct foo_vector
{
foo* data;
unsigned int sz;
void push_back(const foo& x)
{
data[sz++] = x;
}
};

Généricité
138
struct vector
{
T* data;
unsigned int sz;
void push_back(const T& x)
{
data[sz++] = x;
}
};
auto int_vec = vector<int>{};
auto foo_vec = vector<foo>{};

Généricité
138
struct vector
{
T* data;
unsigned int sz;
void push_back(const T& x)
{
data[sz++] = x;
}
};
auto int_vec = vector<int>{};
auto foo_vec = vector<foo>{};
“instanciation” du
type générique
vector
avec un entier

Généricité
139
int sum(const std::vector<int>& vec)
{
auto acc = int{};
acc = acc + x;
return acc;
}
une nécessité pour les algorithmes…
const auto vec0 = std::vector<int>{1,2,3};
const auto s0 = sum(vec0);
const auto vec1 = std::vector<foo>{1,2,3};
struct foo;
foo operator+(const foo&, const foo&);
foo sum(const std::vector<foo>& vec)
{
auto acc = foo{};
acc = acc + x;
return acc;
}

Généricité
140
int sum(const std::vector<int>& vec)
{
auto acc = int{};
acc = acc + x;
return acc;
}
foo sum(const std::vector<foo>& vec)
{
auto acc = foo{};
acc = acc + x;
return acc;
}

Généricité
141
T sum(const std::vector<T>& vec)
{
auto acc = T{};
{
acc = acc + x;
}
return acc;
}

Généricité
141
T sum(const std::vector<T>& vec)
{
auto acc = T{};
{
acc = acc + x;
}
return acc;
}
rien n’a
changé!

Structures templates
142
struct foo
{
T x_;
foo(const T& x) : x_(x) {}
const T& x() const {return x_;}
T& x() {return x_;}
};
auto f_int = foo<int>{42};
f_int.x() += 2;
auto f_char = foo<char>{'a'};
f_char.x() = 'b';

142
struct foo
{
T x_;
T& x() {return x_;}
};
paramètre générique : c’est
un type, pas une valeur
f_int.x() += 2;
f_char.x() = 'b';

142
struct foo
{
T x_;
T& x() {return x_;}
};
paramètre générique : c’est
un type, pas une valeur
accès au type dans toute la classe
f_int.x() += 2;
f_char.x() = 'b';

Fonctions templates
143
struct foo{};
template <typename T, typename U>
void fun0(const T&, const U&);
void fun1(const T&);
fun0(0, foo{});
fun1<int, foo>(0);
déduction automatique à partir des arguments

Fonctions templates
143
struct foo{};
fun0(0, foo{});
fun1<int, foo>(0);
tous les types sont
présents dans les
arguments

Fonctions templates
143
struct foo{};
fun0(0, foo{});
fun1<int, foo>(0);
tous les types sont
présents dans les
arguments
les types ne sont pas tous présents
dans les arguments, il donc les expliciter

Fonctions templates
144
struct foo
{
T x;
};
foo<T> mk_foo(const T& x)
{
return {x};
}
const auto f0 = foo<int>(42);
const auto f1 = mk_foo(42);
pratique pour “cacher” l’argument du template

Fonctions templates
144
struct foo
{
T x;
};
foo<T> mk_foo(const T& x)
{
return {x};
}
const auto f0 = foo<int>(42);
const auto f1 = mk_foo(42);
pratique pour “cacher” l’argument du template
pas de type explicite

Fonctions templates
145
les fonctions membres peuvent être aussi génériques
struct foo
{
T x_;
template <typename U>
void bar(const U&) {}
};
auto f = foo<int>{42};
f.bar(3.22);

Fonctions templates
145
les fonctions membres peuvent être aussi génériques
struct foo
{
T x_;
void bar(const U&) {}
};
auto f = foo<int>{42};
f.bar(3.22);méthode générique

Templates :“fabriques”
146
• Une structure template est une “fabrique de type”
‣ template <typename T> struct foo n’est pas un type
- on ne peut pas créer d’objet de type foo<T>
‣ foo<int> est “généré” à partir de foo<T>
- c’est un type, on peut créer un objet à partir de foo<int>
• Une fonction template est une “fabrique de fonctions”
‣ on n’appelle pas directement template <typename T> foo()

Accès à un type imbriqué
147
struct bar
{
typedef int value_type;
};
void foo(const bar&)
{
bar::value_type x;
}
dans un contexte non-générique

147
struct bar
{
};
void foo(const bar&)
{
bar::value_type x;
}
dans un contexte non-générique
OK

148
struct bar
{
};
void foo(const T&)
{
T::value_type x;
}
error: missing 'typename' prior to dependent type name 'T::value_type'
  T::value_type x;
  ^~~~~~~~~~~~~
  typename
dans un contexte générique

148
struct bar
{
};
void foo(const T&)
{
T::value_type x;
}
error: missing 'typename' prior to dependent type name 'T::value_type'
  T::value_type x;
  ^~~~~~~~~~~~~
  typename
!

149
struct bar
{
};
void foo(const T&)
{
typename T::value_type x;
}

149
struct bar
{
};
void foo(const T&)
{
typename T::value_type x;
}
OK

150
Dependant templates
struct bar
{
U get() const {}
};
void foo(const T& b)
{
const auto x = b.get<int>();
}
auto b = bar{};
foo(b);
error: use 'template' keyword to treat 'get' as a dependent template name
  const auto x = b.get<T>();
                   ^
                   template

150
Dependant templates
struct bar
{
U get() const {}
};
{
const auto x = b.get<int>();
}
auto b = bar{};
foo(b);
error: use 'template' keyword to treat 'get' as a dependent template name
  const auto x = b.get<T>();
                   ^
                   template
!

151
Dependant templates
struct bar
{
U get() const {}
};
{
const auto x = b.template get<int>();
}

151
Dependant templates
struct bar
{
U get() const {}
};
{
}
OK

151
Dependant templates
struct bar
{
U get() const {}
};
{
}
OK
get est une fonction template qui
dépend du type T qui est lui
même un paramètre template

alias
152
// the old way
typedef int my_typedef;
// aliases
using my_alias = int;
using : successeur de typedef

alias
152
// the old way
typedef int my_typedef;
// aliases
using my_alias = int;
lecture homogène avec auto var = …;
using : successeur de typedef

alias
153
struct foo{};
struct templated_typedef
{
typedef foo<T, int> type;
};
int main()
{
const auto f = templated_typedef<int>::type{};
}
essayons tout de même (1)
impossible d’avoir des typedef template

alias
154
struct foo{};
{
};
void bar(const typename templated_typedef<T>::type&);
int main()
{
bar(f);
}

alias
154
struct foo{};
{
};
int main()
{
bar(f);
}
note: candidate template ignored: couldn't infer template argument 'T'
!

alias
155
struct foo{};
using alias_t = foo<T, int>;
int main()
{
const auto f0 = foo<double, int>{};
const auto f1 = alias_t<int>{};
}
alias templates

Règles de déductions
156
void f(ParamType param);
f(expression);
deux types à déduire
void f(const T& param);
int x = 42;
f(x);
pseudo-code :

156
f(expression);
type deT
int x = 42;
f(x);
pseudo-code :

156
f(expression);
type deT
type de param
int x = 42;
f(x);
pseudo-code :

156
f(expression);
type deT
type de param
int x = 42;
f(x);
int
pseudo-code :

156
f(expression);
type deT
type de param
int x = 42;
f(x);
int
const int&
pseudo-code :

• Trois cas, le type de param
‣ est un pointeur ou une référence
‣ n’est ni un pointeur ni une référence
‣ est une référence universelle
157

158
ParamType : pointeur ou référence (1)
void f(T& param);
int x = 2;
const int cx = x;
const int& rx = x;
T param
f(x) int int&
f(cx) const int const int&
f(rx) const int const int&

158
void f(T& param);
int x = 2;
const int cx = x;
const int& rx = x;
T param
f(x) int int&
idem
pour les pointeurs

159
int x = 2;
const int cx = x;
const int& rx = x;
T param
f(x) int const int&

159
int x = 2;
const int cx = x;
const int& rx = x;
T param
f(x) int const int&
idem
pour les pointeurs

160
ParamType : ni pointeur, ni référence
void f(T param);
int x = 2;
const int cx = x;
const int& rx = x;
T param
f(x) int int
f(cx) int int
f(rx) int int

160
void f(T param);
int x = 2;
const int cx = x;
const int& rx = x;
T param
f(x) int int
f(cx) int int
f(rx) int int
par valeur

160
void f(T param);
int x = 2;
const int cx = x;
const int& rx = x;
T param
f(x) int int
f(cx) int int
f(rx) int int
par valeur
copie :
const est ignoré

161
ParamType : rvalue reference
void f(T&& param);
int x = 2;
const int cx = x;
const int& rx = x;
T param
f(x) int& int&
f(cx) const int& const int&
f(rx) const int& const int&
f(42) int int&&
lvalues
rvalues

161
void f(T&& param);
int x = 2;
const int cx = x;
const int& rx = x;
T param
f(x) int& int&
f(42) int int&&
idem
pour les pointeurs
lvalues
rvalues

161
void f(T&& param);
int x = 2;
const int cx = x;
const int& rx = x;
T param
f(x) int& int&
f(42) int int&&
idem
pour les pointeurs
lvalues
rvalues
“référence universelle”

162
void print_type()
{
std::cout << __PRETTY_FUNCTION__;
}
Afﬁcher le type déduit
void print_type() [T = foo]
(GCC, clang)

163
void print_type()
{
std::cout << __FUNCSIG__;
}
void _cdecl print_type<struct foo>(void)
(Visual Studio 2013)

164
struct print_type;
print_type<foo>{};
(tous compilateurs)
error: implicit instantiation of undefined template 'print_type<foo>'
print_type<foo>{};
^

164
struct print_type;
print_type<foo>{};
(tous compilateurs)
ne pas donner de
déﬁnition
error: implicit instantiation of undefined template 'print_type<foo>'
print_type<foo>{};
^

Spécialisation
165
scénario : un algorithme peut-être optimisé pour un type particulier
struct foo{};
struct algo
{
void operator()()
{std::cout << "O(n)";}
};
template <>
struct algo<foo>
{
void operator()()
{std::cout << "O(1)";}
};
algo<foo>{}(); // “O(1)”
algo<int>{}(); // “O(n)”

Spécialisation
165
struct foo{};
struct algo
{
void operator()()
};
template <>
struct algo<foo>
{
void operator()()
{std::cout << "O(1)";}
};
algo<foo>{}(); // “O(1)”
algo<int>{}(); // “O(n)”
générique

Spécialisation
165
struct foo{};
struct algo
{
void operator()()
};
template <>
struct algo<foo>
{
void operator()()
{std::cout << "O(1)";}
};
algo<foo>{}(); // “O(1)”
algo<int>{}(); // “O(n)”
spécialisation
générique

Spécialisation
166
fonctions
struct foo{};
void algo(const T&)
{
std::cout << "O(n)";
}
template <>
void algo(const foo&)
{
std::cout << "O(1)";
}
algo(foo{}); // “O(1)”
algo(42); // “O(n)”

Spécialisation
166
fonctions
struct foo{};
void algo(const T&)
{
}
template <>
{
}
algo(foo{}); // “O(1)”
algo(42); // “O(n)”
générique

Spécialisation
166
fonctions
struct foo{};
void algo(const T&)
{
}
template <>
{
}
algo(foo{}); // “O(1)”
algo(42); // “O(n)”
spécialisation
générique

Spécialisation
167
fonctions, une petite surprise…
void algo(const T&)
{
}
template <>
{
}
{
std::cout << "O(1) bis";
}
algo(foo{}); // “O(1) bis”
algo(42); // “O(n)”

Spécialisation
167
void algo(const T&)
{
}
template <>
{
}
{
}
algo(42); // “O(n)”
spécialisation
générique
surcharge

Spécialisation
167
void algo(const T&)
{
}
template <>
{
}
{
}
algo(42); // “O(n)”
spécialisation
générique
surcharge
préférer les surcharges
aux spécialisations

Spécialisation partielle
168
scénario : un algorithme peut-être optimisé pour un
conteneur générique particulier
struct algo
{
void operator()() {std::cout << "O(n)";}
};
struct algo<std::vector<T>>
{
void operator()() {std::cout << "O(1)";}
};
algo<int>{}(); // “O(n)”
algo<std::vector<int>>{}(); // “O(1)”

168
struct algo
{
};
{
};
algo<int>{}(); // “O(n)”
générique

168
struct algo
{
};
{
};
algo<int>{}(); // “O(n)”
générique
spécialisation
partielle

169
on peut garder des spécialisations totales
struct algo
{
};
{
};
template <>
struct algo<std::vector<double>>
{
void operator()() {std::cout << "O(1) double";}
};
algo<int>{}(); // “O(n)”
algo<std::vector<double>>{}(); // “O(1) double”

169
struct algo
{
};
{
};
template <>
{
};
algo<int>{}(); // “O(n)”
générique

169
struct algo
{
};
{
};
template <>
{
};
algo<int>{}(); // “O(n)”
générique
spécialisation
partielle

169
struct algo
{
};
{
};
template <>
{
};
algo<int>{}(); // “O(n)”
générique
spécialisation
partielle
spécialisation
totale

Template-template arguments
170
struct vector {};
template <typename T, template <typename DUMMY> class Container>
struct foo
{
Container<T> cont_;
};
foo<int, vector>{};
prendre en paramètre template un template (1)

170
struct vector {};
struct foo
{
Container<T> cont_;
};
foo<int, vector>{};
obligatoire

170
struct vector {};
struct foo
{
Container<T> cont_;
};
foo<int, vector>{};
obligatoire
nom sans importance
peut être omis

170
struct vector {};
struct foo
{
Container<T> cont_;
};
foo<int, vector>{};
obligatoire
nom sans importance
peut être omis
T est passé à Container

171
template <typename T, template <typename> class Container>
struct foo
{
Container<T> cont_;
};
foo<int, std::vector>{};
error: template template argument has different template parameters than its
corresponding template template parameter
^
note: too many template parameters in template template argument
template <class _Tp, class _Allocator = allocator<_Tp> >
^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
attention aux nombres de paramètres…

171
template <typename T, template <typename> class Container>
struct foo
{
Container<T> cont_;
};
!
error: template template argument has different template parameters than its
corresponding template template parameter
^
note: too many template parameters in template template argument
template <class _Tp, class _Allocator = allocator<_Tp> >
^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
attention aux nombres de paramètres…

Valeurs en paramètres template
172
template <int Value>
struct foo
{
{
std::cout << Value;
}
};
foo<42>{}();
on peut utiliser des valeurs comme paramètres template
template <bool Value>
struct foo
{
{
std::cout << Value;
}
};
foo<true>{}();

173
expressions constantes seulement
struct foo;
const auto i = 42;
auto j = i;
foo<i>{}(); // OK
foo<j>{}(); // ERROR
error: non-type template argument is not a constant expression
^
note: read of non-const variable 'j' is not allowed in a constant expression

173
expressions constantes seulement
struct foo;
const auto i = 42;
auto j = i;
foo<i>{}(); // OK
!
error: non-type template argument is not a constant expression
^
note: read of non-const variable 'j' is not allowed in a constant expression

174
la spécialisation fonctionne aussi
struct fact
{
static const auto value = Value * fact<Value - 1>::value;
};
template <>
struct fact<0>
{
static const auto value = 1;
};
std::cout << fact<5>::value; // 120

174
la spécialisation fonctionne aussi
struct fact
{
static const auto value = Value * fact<Value - 1>::value;
};
template <>
struct fact<0>
{
static const auto value = 1;
};
std::cout << fact<5>::value; // 120
récursion : cas général
récursion : cas de base

Curiously RecurringTemplate Pattern (CRTP)
175
struct foo
{};
struct bar
: public foo<bar>
{};
classe héritée générique

Variadic templates
176
template<typename T>
T add(T x)
{
return x;
}
template<typename T, typename... Ts>
T add(T x, Ts... xs)
{
return x + add(xs...);
}
add(1,2); // 3
add(1,2,3); // 6
add(1,2,3,4); // 10
// etc.
nombre variable de paramètres template

Variadic templates
176
T add(T x)
{
return x;
}
{
}
add(1,2); // 3
add(1,2,3); // 6
add(1,2,3,4); // 10
// etc.
“parameter pack”

Variadic templates
176
T add(T x)
{
return x;
}
{
}
add(1,2); // 3
add(1,2,3); // 6
add(1,2,3,4); // 10
// etc.
expansion du pack
“parameter pack”

Variadic templates
177
int add(int arg1)
{
return arg1;
}
int add(int arg1, int arg2)
{
return arg1 + add(arg2);
}
int add(int arg1, int arg2, int arg3)
{
return arg1 + add(arg2, arg3);
}
add(1,2,3); // 6
code “déroulé”
T add(T x)
{
return x;
}
{
}

Variadic templates
178
raisonnement programmation fonctionnelle pure
T add(T x)
{
return v;
}
{
}
“déconstruction" de la liste de types head::tail
Caml, Standard ML, Haskell, Scala, etc.

Variadic templates
178
T add(T x)
{
return v;
}
{
}
head

Variadic templates
178
T add(T x)
{
return v;
}
{
}
head tail

Variadic templates
178
T add(T x)
{
return v;
}
{
}
head tail
head

Variadic templates
179
T add(T v)
{
return v;
}
template<typename T, typename... Args>
T add(T first, Args... args)
{
return first + add(args...);
}
std::string operator ""_s(const char *str, std::size_t)
{
return {str};
}
add(“1”_s,"2"_s,"3"_s); // “123”
pour le plaisir…

Variadic templates
180
// Signature of a meta-function that add integers
template <int... Xs>
struct add;
template <int X, int... Xs>
struct add<X, Xs...>
{
static const auto value = X + add<Xs...>::value;
};
template <int X>
struct add<X>
{
static const auto value = X ;
};
add<1,2,3>::value; // 6
les struct/class aussi

Variadic templates
181
connaître la taille d’un pack avec sizeof...
template <typename... Ts>
std::size_t foo()
{
return sizeof...(Ts);
}
std::cout << foo<int, double, char>(); // 3

Variadic templates
182
expansion d’un pack (1)
struct foo{};
template<typename X, typename Y, typename... Z>
void
bar(X, Y, Z...)
{
print_type< foo<X, Y, Z...> >();
print_type< foo<X, Z..., Y> >();
print_type< foo<Z..., X, Y> >();
}
bar(int{}, int{}, double{}, std::string{});
void print_type() [T = foo<int, int, double, std::__1::basic_string<char> >]
void print_type() [T = foo<int, double, std::__1::basic_string<char>, int>]
void print_type() [T = foo<double, std::__1::basic_string<char>, int, int>]

Variadic templates
182
struct foo{};
template<typename X, typename Y, typename... Z>
void
bar(X, Y, Z...)
{
print_type< foo<X, Y, Z...> >();
print_type< foo<X, Z..., Y> >();
print_type< foo<Z..., X, Y> >();
}
bar(int{}, int{}, double{}, std::string{});
void print_type() [T = foo<int, int, double, std::__1::basic_string<char> >]
void print_type() [T = foo<int, double, std::__1::basic_string<char>, int>]
void print_type() [T = foo<double, std::__1::basic_string<char>, int, int>]
Z… en dernière position

Variadic templates
183
template<typename... Values>
std::array<int, sizeof...(Values)>
make_array(Values... values)
{
return std::array<int, sizeof...(Values)>{values...};
}
const auto a = make_array(1,2,3);
template<typename... Args>
void
foo(Args... values)
{
int tab[sizeof...(Args)] = {values...};
}
foo(1,2,3);

Variadic templates
184
expansion d’un pack : héritage
struct base1
{
void foo(){}
};
struct base2
{
void bar(){}
};
template <typename... Bases>
class derived
: public Bases...
{};
auto d = derived<base1, base2>{};
d.foo();
d.bar();

Variadic templates
185
spécialisation
struct foo
{};
struct bar;
struct bar<foo<Ts...>>
{};
using foo_type = foo<int, char>;
using bar_type = bar<foo_type>;

Variadic templates
185
spécialisation
struct foo
{};
struct bar;
struct bar<foo<Ts...>>
{};
using foo_type = foo<int, char>;
using bar_type = bar<foo_type>;
permet d’accéder
à liste de
paramètres de foo

Variadic templates
186
struct tuple {};
template <typename T, typename... Ts>
struct tuple<T, Ts...>
: tuple<Ts...>
{
tuple(T t, Ts... ts)
: tuple<Ts...>(ts...)
, current(t)
{}
T current;
};
structure récursive

Références universelles
187
void f(T&& param);
• Dénomination de Scott Meyers
• En présence d’une déduction de type (templates)
• Il faudrait parler de
‣ forwarding reference
‣ en cours de standardisation (la dénomination)
‣ http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/
n4164.pdf

Références universelles
187
void f(T&& param);
• Dénomination de Scott Meyers
• En présence d’une déduction de type (templates)
• Il faudrait parler de
‣ forwarding reference
‣ en cours de standardisation (la dénomination)
‣ http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/
n4164.pdf
&& sur paramètre template

Perfect forwarding
188
le problème : passer des paramètres
de manière transparente à une sous-fonction
template <typename Fun, typename T>
void logger(const T& x)
{
std::cout << "beforen";
Fun{}(x);
std::cout << "aftern";
}
template <typename Fun, typename T>
void logger(T& x)
{
Fun{}(x);
}
et s’il y a plusieurs paramètres?…

Perfect forwarding
solution : std::forward
template <typename Fun, typename Arg>
void logger(Arg&& x)
{
Fun{}(std::forward<Arg>(x));
}

Perfect forwarding
190
comment ça fonctionne? (1)
A& & → A&
A& && → A&
A&& & → A&
A&& && → A&&
si invocation f(a)
a de type A Arg x
lvalue A& A&
rvalue A&& A&&
template<typename Arg>
void f(Arg&& x);
“collapsing rules”
application des collapsing rules

Perfect forwarding
191
comment ça fonctionne? (2)
template<class T>
T&&
forward(typename remove_reference<T>::type& a)
{
return static_cast<T&&>(a);
}

Perfect forwarding
192
void logger(X& && x)
{
Fun{}(std::forward<X&>(x));
}
X& &&
forward(typename remove_reference<X&>::type& a)
{
return static_cast<X& &&>(a);
}
void logger(X& x)
{
Fun{}(std::forward<X&>(x));
}
X&
forward(X& a)
{
return static_cast<X&>(a);
}
sur une lvalue

Perfect forwarding
193
sur une rvalue
void logger(X&& && x)
{
Fun{}(std::forward<X&&>(x));
}
X&& &&
forward(typename remove_reference<X&&>::type& a)
{
return static_cast<X&& &&>(a);
}
void logger(X&& x)
{
Fun{}(std::forward<X&&>(x));
}
X&&
forward(X& a)
{
return static_cast<X&&>(a);
}

Perfect forwarding vs move
194
void foo(int&&) {std::cout << "int&&";}
void foo(const int&) {std::cout << "const int&";}
void foo(int&) {std::cout << "int&";}
void apply(T&& x)
{
std::cout << "A";
foo(std::forward<T>(x));}
}
void apply(int&& x)
{
std::cout << "B";
foo(std::move(x));
}
apply(i);
apply(ri);
apply(cri);
apply(42);
apply(std::move(i));
quel est l’afﬁchage?
auto i = 2;
auto& ri = i;
const auto& cri = i;

196
begin/end
auto vec = std::vector<int>{1,2,3};
auto it = begin(vec); // vec.begin()
*it = 42;
auto cit = cbegin(vec); // vec.cbegin()
*cit = 33; // error
fonctions libres
for (auto cit = cbegin(vec); cit != cend(vec); ++cit)
{
// ...
}

197
begin/end
tableaux C
int tab[] = {1,2,3};
for (auto it = std::begin(tab); it != std::end(tab); ++it)
{
*it = 0;
}

197
begin/end
tableaux C
int tab[] = {1,2,3};
for (auto it = std::begin(tab); it != std::end(tab); ++it)
{
*it = 0;
}
appel “fully qualiﬁed”

198
next/prev
auto vec = std::vector<int>{1,2,3};
auto it = begin(vec);
auto it1 = next(it); // return a copy incremented by 1
auto it2 = next(it, 2); // return a copy incremented by 2
auto it3 = prev(it2); // return a copy decremented by 1
auto it4 = prev(it3, 1); // return a copy decremented by 1

199
move
déplacer un conteneur
auto vec1 = std::vector<foo>{foo{}, foo{}};
auto vec2 = std::vector<foo>{};
std::cout << vec1.size();
std::move(begin(vec1), end(vec1), std::back_inserter(vec2));

200
all_of, any_of, any_of
auto vec1 = std::vector<bool>{true, true, true};
auto vec2 = std::vector<bool>{true, false, true};
std::cout << std::boolalpha;
std::cout << std::all_of( begin(vec1), end(vec1)
, [](bool x){return x;});
std::cout << std::any_of( begin(vec2), end(vec2)
, [](bool x){return not x;});

201
emplace, emplace_back
construction en place grâce au perfect forwarding
struct foo
{
foo(int)
{std::cout << "foo(int)";}
foo(const foo&)
{std::cout << "foo(const foo&)";}
foo& operator=(const foo&)
{std::cout << "operator=(const foo&)"; return *this;}
foo(foo&&)
{std::cout << "foo(foo&&)";}
foo& operator=(foo&&)
{std::cout << "operator=(foo&&)"; return *this;}
};
auto vec1 = std::vector<foo>{};
vec1.reserve(3);
auto f = foo{1};
vec1.push_back(f);
vec1.push_back(foo{2});
vec1.emplace_back(3);

202
shrink_to_fit
deque, string et vector
auto vec1 = std::vector<int>{};
std::cout << vec1.capacity();
vec1.push_back(1);
vec1.push_back(1);
vec1.push_back(1);
vec1.shrink_to_fit();
peut libérer de la mémoire

203
forward_list
liste simplement chaînée
auto l = std::forward_list<int>{1,2,3};
std::cout << l.size(); // error, no size() member
auto cit0 = begin(l);
auto cit1 = next(cit0);
auto cit2 = prev(cit1); // error, not bidirectional

204
array
auto a1 = std::array<int, 3>{};
const auto cit = a1.cbegin();
const auto& x = a1[2]; // use like a C-array
const auto& y = a1.at(10); // std::out_of_range
auto a2 = std::array<int, 3>{};
if (a1 == a2)
{
// ...
}
auto a3 = a1;
// etc.
tableaux C pour le C++
strictement les mêmes performances!
à privilégier dans tout nouveau code

205
array
const auto a0 = std::array<int, 3>{1,2,3};
const auto a1 = a0;
toutes les facilités du C++ (1)
const int t0[3] = {1,2,3};
int t1[3];
std::copy(t0, t0 + 3, t1);
vs
copie

205
array
const auto a1 = a0;
dangereux
const int t0[3] = {1,2,3};
int t1[3];
std::copy(t0, t0 + 3, t1);
vs
copie

206
array
const auto res = std::find(begin(a0), end(a0), 3);
if (res != end(a0))
{
std::cout << "foundn";
}
utilisation des algorithmes STL

207
array
auto a0 = std::array<int, 3>{1, 2, 3};
auto a1 = std::array<int, 3>{1, 99, 3};
const auto res = memcmp(a0.data(), a1.data(), 3 * sizeof(int));
std::cout << res << 'n';
memcpy(a0.data(), a1.data(), 3 * sizeof(int));
for (auto x : a0)
{
}
utilisation avec les fonctions C
.data() pour accéder au tableau C

208
tuple
conteneur de types hétérogène
auto t1 = std::tuple<int, char, foo>{2, 'a', foo{}};
auto t2 = std::make_tuple(2, 'a', foo{});
const auto& f = std::get<2>(t2);

209
tuple
permet de retourner plusieurs valeurs
sans avoir à créer un nouveau type (1)
struct foo {};
std::tuple<int, foo>
bar()
{
return std::make_tuple(2, foo{});
}
const auto t = bar();

210
tuple
permet de retourner plusieurs valeurs
sans avoir à créer un nouveau type (2)
struct foo {};
std::tuple<int, foo>
bar()
{
return std::make_tuple(2, foo{});
}
auto i = 0;
auto f = foo{};
std::tie(i, f) = bar();
std::cout << i; // 2

211
tuple
concaténer des tuples
auto t0 = std::make_tuple(1, foo{}, 'a');
std::cout << std::tuple_size<decltype(t0)>::value; // 3
auto t1 = std::make_tuple(3.14, std::string{"abc"});
auto t2 = std::tuple_cat(t0, t1);

212
unordered_map
table de hachage
auto map = std::unordered_map<int, std::string>{};
map.insert({42, "abc"});
map.emplace(33, "def");
for (const auto& key_value : map)
{
std::cout << key_value.first << " -> " << key_value.second;
}
fonctionne comme std::map

213
unordered_map
fonctions spéciﬁques aux tables de hachage
auto map = std::unordered_map<int, std::string>{1'000'000};
peut-être initialisée avec un nombre de buckets
map.rehash(2'000'000);
peut-être redimensionnée
map.load_factor()
afﬁcher le facteur de charge

214
unordered_map
utiliser un type personnalisé en tant que clé
namespace std
{
template <>
struct hash<foo>
{
std::size_t
operator()(const foo& f)
const
{
// hash function
}
};
}
bool operator==(const foo&, const foo&);
struct foo
{
// some data
};
clé
égalité
hachage

214
unordered_map
utiliser un type personnalisé en tant que clé
namespace std
{
template <>
struct hash<foo>
{
std::size_t
const
{
// hash function
}
};
}
bool operator==(const foo&, const foo&);
struct foo
{
// some data
};
clé
égalité
hachage
spécialisation

215
unordered_map
bonus: combiner des valeurs de hachage (1)
/// @brief Combine the hash value of x with seed.
///
/// Taken from <boost/functional/hash.hpp>.
/// Sligthy modified to use std::hash<T> instead of
/// boost::hash_value().
inline
void
hash_combine(std::size_t& seed, const T& x)
noexcept(noexcept(std::hash<T>()(x)))
{
seed ^= std::hash<T>()(x) + 0x9e3779b9 + (seed<<6) + (seed>>2);
}

216
unordered_map
bonus: combiner des valeurs de hachage (2)
namespace std
{
template <>
struct hash<foo>
{
std::size_t
const
{
auto seed = 0ul;
hash_combine(seed, f.x);
hash_combine(seed, f.y);
return seed;
}
};
}

217
Gestion de la mémoire
• introduction de unique_ptr
‣ auto_ptr deprecated
‣ utilise les portées pour désallouer
• introduction de shared_ptr
‣ déjà présent dans Boost et POCCO
‣ comptage de référence
• désallocation automatique dans tous les cas

C++ 11/14

Recomendados

Recomendados

Mais conteúdo relacionado

Mais procurados

Mais procurados (20)

Destaque

Destaque (20)

Semelhante a C++ 11/14

Semelhante a C++ 11/14 (20)

C++ 11/14