Programmation C++11/17

Dr. Ing. Chiheb Ameur ABID

Contact : [Link]@[Link]

Mars 2024
Journée 1 Chiheb Ameur ABID 2/ 68
Historique et évolution du langage C++

Plan

1 Historique et évolution du langage C++

2 Littéraux
ID
r AB
3 Les espaces de noms Chiheb Ameur u
e ABID
b Am
ih e
4 Ch
Les nouveautés du langage C++11/C++17

5 Références et expressions

6 Les attributs
Journée 1 Chiheb Ameur ABID 3/ 68
Historique et évolution du langage C++

Les langages C/C++

Les langages C et C++

å Performance (Langages compilés)
å Empreinte mémoire faible
å Portabilité
å Bibliothèques existantes (C depuis 1971, C++ depuisID1983)
AB
Chiheb Ameur e ur ABID
Compilation Am
i h eb
Ch
Journée 1 Chiheb Ameur ABID 4/ 68
Historique et évolution du langage C++

Les langages C/C++

Historique
å En 1970, Ken Thompson, créa un nouveau langage : Le B
Z Simple, mais trop dépendant de l’architecture utilisée
å En 1971, Dennis Ritchie commence à mettre au pointIDle successeur du B, le C.
Z Portable, r AB
Chiheb (peut
Ameuru
e ABID
Z Langage bas niveau : performant
b Am créer du code aussi rapide que de
l’assembleur) ih e
Ch de haut niveau
Z Permet de traiter des problèmes
å En 1989, l’ANSI (American National Standards Institute) normalisa le C sous les
dénominations ANSI C ou C89
Journée 1 Chiheb Ameur ABID 5/ 68
Historique et évolution du langage C++

Historique
å En 1983, Bjarne Stroustrup des laboratoires Bell crée le C++
Z Basé sur le C, il garde une forte compatibilité avec le C
å La première normalisation de C++ date de 1998 (C++98)

ID
r AB
Chiheb Ameur u
e ABID
b Am
ih e
Ch
Journée 1 Chiheb Ameur ABID 6/ 68
Historique et évolution du langage C++

Évolution de C++

Évolution de C++

ID
r AB
Chiheb Ameur u
e ABID
b Am
ih e
Ch
Journée 1 Chiheb Ameur ABID 7/ 68
Historique et évolution du langage C++

Compilation

Principaux compilateurs C/C++

å GCC (GNU Compiler Collection) : il s’agit d’un ensemble d’outils Open Source analysant
plusieurs langages (C, C++, Objective C, Ada, Go, Fortran...)
Z Supporte une multitude d’architectures cibles
Z GCC autorise la compilation croisée
BIDde type Unix (comme Linux) et sous
Z GCC est disponible sous la plupart des systèmes
rA
Windows en utilisant l’environnement Cygwin
eu
ChihebauAmeur
å Clang : c’est la principale alternative m ABID
compilateur C++ de GCC
b A
e
ih global LLVM (framework de développement de
Z Il s’intègre au sein du projethplus
compilateur) pour générer C une représentation compilée intermédiaire traduisible
ensuite sur différentes architectures
Z Clang, de conception plus récente, possède une architecture plus modulaire que GCC
et permet d’obtenir des programmes offrant des performances plus ou moins
similaires à GCC
å Intel C++ Compiler : compilateur propriétaire (et gratuit) est développé par Intel pour la
compilation à destination de ses propres processeurs (de type x86) en utilisant certaines
optimisations maison.
å Visual C++ Compiler : compilateur propriétaire de Microsoft pour Windows accompagne
l’environnement de développement Visual Studio de Microsoft
Journée 1 Chiheb Ameur ABID 8/ 68
Historique et évolution du langage C++

Compilation

Compilateur GCC
å GCC est un logiciel libre capable de compiler divers langages de programmation, dont C,
C++, Objective-C, Java, Ada et Fortran BID
rA
u de chaque langage
å Pour faire référence précisément
Chiheb me ABID
aux compilateurs
Ameur
A
gcc : le compilateur C de GNU b
ihe
g++ : le compilateur C++ de GNU Ch
gcj : le compilateur Java de GNU
gobjc : le compilateur Objective-C de GNU
gobjc++ : le compilateur Objective-C++ de GNU
gnat : le compilateur Ada de GNU
gfortran : le compilateur Fortran de GNU
Journée 1 Chiheb Ameur ABID 9/ 68
Historique et évolution du langage C++

Compilation

Compilateur GCC
å Installer GCC
ID
AB
$ sudo apt-get install build-essential
å Compiler un programme Chiheb Ameur ur
e ABID
b Am
Z Programme écrit C ih e
Ch
$ gcc main.c fonctions.c -o Programme
Z Programme écrit en C++
$ g++ [Link] [Link] -o Programme -std=c++17
å Pour le lancer le programme
$ ./Programme
Journée 1 Chiheb Ameur ABID 10/ 68
Historique et évolution du langage C++

Compilation

Toolchain
Un toolchain est constitué par un ensemble
d’outils permettant de produire le fichier
exécutable
å C++ Preprocessor : Inclure le contenu des
fichiers entêtes (headers), générer les ID
r AB
macros et remplacer les constantes
Chiheb Ameur u
e ABID
définies par #define
b Am
g++ −E [Link] ih e
å Compiler : Traduire en assembleur
Ch
g++ −S [Link]
å Assembler : produire fichier objet binaire
en traduisant les instruction assembleur en
langage machine (binaire)
g++ −c [Link]
å Linker : édition des liens du fichier objet
avec les autres fichiers objets de n’importe
quelle bibliothèque utilisée afin de
produire le fichier exécutable
Journée 1 Chiheb Ameur ABID 11/ 68
Littéraux

Plan

1 Historique et évolution du langage C++

2 Littéraux
ID
r AB
3 Les espaces de noms Chiheb Ameur u
e ABID
b Am
ih e
4 Ch
Les nouveautés du langage C++11/C++17

5 Références et expressions

6 Les attributs
Journée 1 Chiheb Ameur ABID 12/ 68
Littéraux

Les littéraux

Présentation
å Un littéral (aussi appelé constante littérale) est une valeur écrite exactement comme elle
doit être interprétée. D
I
å Exemples de littéraux r AB
Chiheb Ameur u
e ABID
1 "Bonjour, le monde"
b Am
2 "Bjarne"
ih e
3 ’a’ // Caractère minuscule a Ch
4 ’A’ // Caractère majuscule A
5 123
6 123U // Entier non signé 123
7 1’000’000 // Entier séparé par des apostrophes pour la lisibilité
8 3.1415 // Nombre décimal
9 1.0L // Nombre décimal avec suffixe L indiquant un long
10 1.23456789e-10 // Nombre scientifique
Journée 1 Chiheb Ameur ABID 13/ 68
Littéraux

Littéraux de caractère

Littéraux de caractère

BID suivi d’un ou plusieurs

å Un littéral de caractère est constitué d’un préfixe optionnel
caractères placés entre apostrophes simples. r A
eu
å Le type de littéral de caractèreChiheb Ameur ABID
Am par le préfixe (ou son absence)
est déterminé
e b
¶ Littéraux de caractères ordinairesih de type char, par exemple ’a’
· Littéraux de caractères étendusCh de type wchar_t, par exemple L’a’
¸ Littéraux de caractères UTF-16 de type char16_t, par exemple u’a’
¹ Littéraux de caractères UTF-32 de type char32_t, par exemple U’a’
å Les caractères spéciaux peuvent être représentés par une séquence d’échappement
Journée 1 Chiheb Ameur ABID 14/ 68
Littéraux

Les chaînes littérales brutes

Littéraux de chaines de caractères

å C++11 a introduit les chaines littérales brutes pour ne pas interpréter les caractères
spéciaux
Z Il suffit de mettre la chaine de caractères entre R(" et ")
ID
r AB
Chiheb Ameur u
e ABID
Exemple
b Am
å Soit à afficher la chaine : ih e
Ch
printf("Hello, %s%c\n", "World", ’!’);

å En C++03
std::cout << "printf(\"Hello, %s%c\\n\", \"World\", ’!’);"<<std::endl;

å En C++11
std::cout << R"(printf("Hello, %s%c\n", "World", ’!’);)" <<std::endl;
Journée 1 Chiheb Ameur ABID 15/ 68
Littéraux

Les littéraux entiers

Littéraux de chaines de caractères

å Les entiers peuvent être spécifiés en base décimale, binaire, hexadécimale et octale
å La base du nombre est indiquée par un préfixe (ou son absence)
Préfixe Base
Aucun Décimale
ID
0 initial Octale
r AB
0b ou 0B Binaire u
Chiheb Ameur me ABID
0x ou 0X Hexadécimale bA he
å Différents suffixes peuvent être C hi
spécifiés pour contrôler le type du littéral
Suffixe Type
u ou U unsigned (entier non signé)
l ou L long (long int)
u ou U et l ou L (ensemble) unsigned long long (entier non signé long long)
ll ou LL long long (long long int)
u ou U et ll ou LL (ensemble) unsigned long long (entier non signé long long)
å Un apostrophe simple est utilisé comme séparateur de chiffres : 1’000’000
å Un littéral entier est toujours non négatif ; ainsi, par exemple, -1 est le littéral entier 1 avec
l’opération de négation appliquée
Journée 1 Chiheb Ameur ABID 16/ 68
Littéraux

Littéraux définis par l’utilisateur

Littéraux définis par l’utilisateur

å Les littéraux définis par l’utilisateur sont une fonctionnalité du langage qui permet de créer
des raccourcis syntaxiques pour des valeurs ou des expressions courantes, en utilisant des
suffixes personnalisés
ID
å Étapes de création des littéraux définis par l’utilisateur
r AB
Z Définir les littéraux dansChiheb
un espace u
e ABID
de noms
Ameur séparé pour éviter les conflits de noms.
Z Toujours préfixer le suffixe définibparAml’utilisateur avec _
e
hihl’une des formes :
Z Définir un opérateur littéral de
C
1 T operator "" _suffix(unsigned long int);
2 T operator "" _suffix(long double);
3 T operator "" _suffix(char);
4 T operator "" _suffix(wchar_t);
5 T operator "" _suffix(char16_t);
6 T operator "" _suffix(char32_t);
7 T operator "" _suffix(char const *, std::size_t);
8 T operator "" _suffix(wchar_t const *, std::size_t);
9 T operator "" _suffix(char16_t const *, std::size_t);
10 T operator "" _suffix(char32_t const *, std::size_t);
Journée 1 Chiheb Ameur ABID 17/ 68
Littéraux

Littéraux définis par l’utilisateur

Exemple de définition d’un littéral

ID
AB
1 namespace compunits
2 {
u r
e ABID
Chiheb Ameur
constexpr size_t operator "" _KB(unsigned long long const size)
Am
3
4 {
e b
5
ih
return static_cast<size_t>(size * 1024);
6 } Ch
7 }
8
9 auto size{ 4_KB }; // size_t size = 4096;
10 using byte = unsigned char;
11 auto buffer {std::array<byte, 1_KB>{}};
Journée 1 Chiheb Ameur ABID 18/ 68
Les espaces de noms

Plan

1 Historique et évolution du langage C++

2 Littéraux
ID
r AB
3 Les espaces de noms Chiheb Ameur u
e ABID
b Am
ih e
4 Ch
Les nouveautés du langage C++11/C++17

5 Références et expressions

6 Les attributs
Journée 1 Chiheb Ameur ABID 19/ 68
Les espaces de noms

Espace de noms

Présentation
å Un espace de noms est une région qui fournit une portée aux identificateurs déclarés à
l’intérieur
Z Les espaces de noms fournissent un mécanisme pour réduire le risque de conflits de
ID
noms AB
ur
å Syntaxe Chiheb Ameur
A me ABID
b
1 namespace nom { ihe
2 // Corps de l’espace de Ch(code)
noms
3 ...
4 }

Z nom : Identifiant qui nomme l’espace de noms

Z Corps de l’espace de noms : Code contenu dans l’espace de noms
å Évolutions des espaces de noms
Z C++11 : espaces de noms inline
Z C++17 : espaces de noms imbriqués
Journée 1 Chiheb Ameur ABID 20/ 68
Les espaces de noms

Espace de noms

Utilisations
å Utilisation de différents modules et bibliothèques dans un programme
Z Problème dit de ń pollution de l’espace de noms ż : Un même identificateur peut être
utilisé par plusieurs modules ou bibliothèquesBI
D
r A
Z Risque d’ambiguité
Chiheb Ameur e
ABID u
b Am
ih e
Exemple d’espace de noms Ch
å Donner un nom à un espace de déclaration
1 namespace mon_module {
2 //declarations usuelles
3 extern double taux;
4 double conversion(double);
5 }
Journée 1 Chiheb Ameur ABID 21/ 68
Les espaces de noms

Espace de noms

Utiliser les espaces de noms

å Pour se référer à des identificateurs définis dans un espace de noms, on utilise l’opérateur
:: de résolution de portée
1 double mon_module::taux=6.5;
ID
AB
2 std::cout << mon_module::conversion(1);
u r
e ABID
Z On dit aussi que l’on se Chiheb Ameur
Am
réfère à l’identificateur taux déclaré dans la portée de
mon_module h e b
h i
å À l’intérieur de mon_module,Con utilise directement le nom taux
1 double mon_module::conversion(double a)
2 {
3 return a*taux; // mon_module::taux
4 }

å L’espace des déclarations globales d’un programme est aussi un espace de noms dit portée
globale
Z ::x fait référence à l’identificateur x de la portée globale
Journée 1 Chiheb Ameur ABID 22/ 68
Les espaces de noms

Espace de noms

Utiliser les espaces de noms

å La déclaration using permet de faire entrer (connaître) un identificateur dans la portée
courante D I
1 using mon_module::taux; r AB
Chiheb Ameur u
e ABID
Am
2 std::cout << taux;

e b
Z ih
Ch portée globale alors ::taux et
Si on fait entrer taux dans la
mon_module::taux deviennent des écritures équivalentes
Z Attention : il ne doit pas y avoir d’autre taux dans la portée courante
å La directive using permet de rendre visibles les noms définis dans un espace de noms
1 using namespace mon_module;
2 std::cout << conversion(3);
Journée 1 Chiheb Ameur ABID 23/ 68
Les espaces de noms

Espace de noms

Utilisation de la directive using

å Risques d’ambigüités si plusieurs espaces de noms comportant des identificateurs
identiques sont rendus visibles ID
AB
1 using namespace mon_module;
Chiheb Ameur e ur ABID
Am
2 //espace de nom declarant taux
3
4
using namespace son_module;
//espace de nom declarant taux i h eb
5 Ch
std::cout << taux; //appel ambigu

å Le compilateur signale
Z Les ambigüités entre identifiants des espaces de noms rendus visibles
Z Mais pas les surcharges de fonctions à travers les espaces de noms !
å Il est parfois plus prudent d’utiliser une déclaration using qu’une directive using !
Journée 1 Chiheb Ameur ABID 24/ 68
Les espaces de noms

Espace de noms

Espace de noms imbriqués

å Permettent de créer une hiérarchie d’espaces de noms
Z Une organisation plus fine du code et une meilleure gestion des conflits de noms.
å Utilisation des espaces de noms imbriqués ID
r AB
1 namespace foo {
Chiheb Ameur u
e ABID
2
3
namespace bar {
namespace impl { b Am
// ... ih e
Ch
4
5 }
6 }
7 }

å En C++, une écriture équivalente

1 // Une autre écriture équivalente
2 namespace foo::bar::impl {
3 // ...
4 }
Journée 1 Chiheb Ameur ABID 25/ 68
Les espaces de noms

Espace de noms

Espace de noms inline

å Permet de créer des espaces de noms imbriqués dont les membres sont automatiquement
considérés comme faisant partie de l’espace de noms englobant.
Z Les inline namespaces sont utilisés pour gérer les versions d’une bibliothèque et
éviter les conflits de noms entre les différentes versions
ID
AB
Chiheb Ameur eur
Exemple de gestion des versions avec inline namespace
ABID
b Am
1 namespace modernlib ih e
2 { Ch
3 #ifndef LIB_VERSION_2
4 inline namespace version_1 {
5 template<typename T>
6 int test(T value) { return 1; }
7 }
8 #endif
9 #ifdef LIB_VERSION_2
10 inline namespace version_2 {
11 template<typename T>
12 int test(T value) { return 2; }
13 }
14 #endif
15 }
Journée 1 Chiheb Ameur ABID 26/ 68
Les espaces de noms

Alias d’espaces de noms

å Un alias de namespace est un identificateur qui peut être introduit comme un alias pour un
espace de noms entier
Z permet de créer des noms plus courts pour les namespaces imbriqués en profondeur
ou les namespaces avec des noms longs
å Syntaxe
namespace alias name = ns::name;.
ID
r AB
Chiheb Ameur u
e ABID
b Am
ih e
1
2
namespace foobar {
namespace miscellany {
Ch
3 namespace experimental {
4 int get_meaning_of_life() {return 42;}
5 void greet() {std::cout << "hello\n";};
6 }
7 }
8 }
9 int main() {
10 namespace n = foobar::miscellany::experimental; // Définition d’un alias
11 n::greet();
12 std::cout << n::get_meaning_of_life() << \n;
13 }
Journée 1 Chiheb Ameur ABID 27/ 68
Les espaces de noms

Espace de noms

Espaces de noms anonymes

å Les entités définies dans un namespace anonyme ne sont visibles que dans son unité de
traduction associée
Z Elles ne sont pas accessibles depuis d’autres unités de traduction
å Syntaxe ID
r AB
namespace alias name = ns::name;.
Chiheb Ameur u
e ABID
b Am
ih e
Ch
1 namespace {
2 const int forty_two = 42;
3 int x;
4 }
5 int main() {
6 x = forty_two;
7 std::cout << x << \n;
8 }

Z La constante forty_two et la variable statique x sont uniquement accessibles dans le

fichier source où ils sont définis
Journée 1 Chiheb Ameur ABID 28/ 68
Les nouveautés du langage C++11/C++17

Plan

1 Historique et évolution du langage C++

2 Littéraux
ID
r AB
3 Les espaces de noms Chiheb Ameur u
e ABID
b Am
ih e
4 Ch
Les nouveautés du langage C++11/C++17

5 Références et expressions

6 Les attributs
Journée 1 Chiheb Ameur ABID 29/ 68
Les nouveautés du langage C++11/C++17

La constante nullptr

La constante nullptr (depuis C++11)

å En C++, la constante NULL correspond à la valeur entière 0 pour représenter un pointeur
nul
Z Source d’ambiguïté
ID
B
rA
å La constante nullptr vise a résoudre ce problème
u
e ABID
Chiheb Ameur
b Am
ih e
1 void foo(char *); Ch
2 void foo(int);

Z L’appel foo(NULL) va appeler probablement foo(int)

1 char *pc = nullptr; // OK
2 int *pi = nullptr; // OK
3 bool b = nullptr; // OK. b is false.
4 int i = nullptr; // error
5 foo(nullptr); // calls foo(char *), not foo(int);
Journée 1 Chiheb Ameur ABID 30/ 68
Les nouveautés du langage C++11/C++17

Les expressions constexpr

Présentation
å Les expressions constexpr ont été introduites en C++11
ID
å constexpr AB
Chihebdont
¶ Déclarer une variable constante lae
Ameur ur ABID
valeur est connue lors de la compilation
b Amune valeur constante à la compilation si ses
· Définir une fonction qui peut produire
e
hih
arguments sont des valeursCconstantes
å L’objectif est de réaliser des calculs pendant la compilation
å En C++, la méta-programmation se base sur les templates méta-fonctions et les fonctions
constexpr
Z Écrire du code qui sera interprété non pas à l’exécution, mais pendant la compilation
Journée 1 Chiheb Ameur ABID 31/ 68
Les nouveautés du langage C++11/C++17

constexpr

Les fonctions constexpr

å En C++11, une constexpr est assez restrictive
Z Elle ne peut rien lire ou écrire en dehors de la fonction
Z Elle ne peut pas contenir de variables
ID
Z Ne peut pas contenir de structures de contrôleBcomme if ou for
r
Z Elle ne peut contenir qu’une seule instruction
A de calcul
Chiheb Ameure u ABID
Amqui sont également constexpr.
Z Elle ne peut appeler que des fonctions
b
ihe
Ch
Exemple

1 constexpr long fibonacci (long n)

2 {
3 return n <= 2 ? 1 : fibonacci ( n - 1) + fibonacci (n - 2);
4 }
5
6 auto x1 {fibonacci(2)}; // Run-time execution
7 constexpr auto x2 {fibonacci(2)}; // Compile-time execution
Journée 1 Chiheb Ameur ABID 32/ 68
Les nouveautés du langage C++11/C++17

constexpr

Les fonctions constexpr

å En C++17, moins de restrictions ont été imposée sur une fonction constexpr
Z Doit avoir un type de retour littéral : un type qui peut être utilisé dans une expression
constante, comme un type intégral, un type flottant, un pointeur, une référence, une
énumération, ou une classe avec un constructeur constexpr.
ID override, final, ou
Z La fonction ne doit pas avoir de spécificateur virtuel,
noexcept r AB
Chihebpas Ameur u
e appels
ABID
Z Pas des allocations dynamiques, m
des à des fonctions non constantes, pas
e b A ou des instructions goto
des modifications de variableshglobales,
i
Ch constexpr, mais pas des fonctions non constantes,
Z Peut appeler d’autres fonctions
sauf si elles sont marquées comme consteval ou constinit.
Z Peut contenir des instructions if, switch, for, while, ou do-while, mais pas des
instructions break ou continue qui ne sont pas immédiatement suivies d’une
instruction de fin de bloc.
Z Peut contenir des variables locales, mais elles doivent être initialisées avec des
expressions constantes
Z Peut contenir des assertions statiques, des déclarations using, des déclarations
typedef, ou des déclarations de types anonymes.
Z Peut contenir des expressions lambda, mais elles doivent être marquées comme
constexpr et respecter les mêmes restrictions que la fonction englobante.
Journée 1 Chiheb Ameur ABID 33/ 68
Les nouveautés du langage C++11/C++17

constexpr

Exemple avec constexpr en C++17

ID
1 constexpr int factorial(int n) {
r AB
2 int result {1};
Chiheb Ameur u
e ABID
3 for (int i {1}; i <= n; ++i) {
result *= i; b Am
4
ih e
Ch
5 }
6 return result;
7 }
8
9 auto x1 (factorial(2)); // Run-time execution
10 constexpr auto x2 (factorial(2)); // Compile-time execution
Journée 1 Chiheb Ameur ABID 34/ 68
Les nouveautés du langage C++11/C++17

Le "range-based" for loop

Le range-based for loop

å Depuis C++11, une nouvelle variante de la boucle for a été introduite pour parcourir une
collection des valeurs : tableaux ou conteneurs
1 for(type d’un élément ou auto identifiant : tableau/conteneur à parcourir) {
2 // Manipuler identifiant, en l’affichant par exemple.
3 } ID
r AB
å Exemple : par recopie Chiheb Ameur u
e ABID
b Am
1 int tab[] { 1, 2, 3, 4, 5 }; ih e
2 for (auto elt : v) Ch
3 std::cout << elt << ’\n’;

Z elt contient une copie d’un élément du tableau

Z La modification de elt ne modifie pas la valeur dans le tableau
å Exemple : par référence
1 int tab[] { 1, 2, 3, 4, 5 };
2 for (auto &elt : v)
3 std::cout << elt << ’\n’;

Z On ajoute const pour empêcher la modification des valeurs

Journée 1 Chiheb Ameur ABID 35/ 68
Les nouveautés du langage C++11/C++17

Initialisation uniforme

Initialisation uniforme
å Fonctionnalité introduite avec le standard C++11
å Utiliser une syntaxe cohérente pour initialiser des variables et des objets, allant des types
ID
primitifs aux agrégats
r AB
Z Éviter certaines ambiguïtés u
Chiheb me ABID
syntaxiques
Ameur
Z Prévenir les conversions implicitesbA
he
i
Ch {}
å Basée sur l’utilisation des accolades
type var_name{arg1, arg2, ....arg n}

å Éviter l’ambiguité avec l’opérateur d’affectation

1 std::vector<int> v1={1,2,3};
2 auto v2=v1; // Pas d’effectation ; constructeur par recopie
3 auto v3 {v1};
Journée 1 Chiheb Ameur ABID 36/ 68
Les nouveautés du langage C++11/C++17

Initialisation uniforme

Initialisation uniforme
å Initialisation des types primitifs
Z Légèrement plus sûre pour les conversions étroites
1 int count1(7.5); // Peut compiler sans avertissement
ID
2
r AB
int count2 = 5.3; // Peut compiler sans avertissement
3 u
e ABID
int count3{0.3}; // Au moins un avertissement, souvent une erreur
Chiheb Ameur
b Am
å Initialisation par valeur ih e
Ch
Z Initialise à 0 les types primitifs
Z Fait appel au constructeur par défaut pour les classes
1 int x; // Valeur quelconque
2 int i{}; // i prend 0

Z Éviter une ambiguïté syntaxique

1 std::string s1(); // Déclaration d’une fonction qui renvoie un std:string
2 std::string s2{}; // Création d’une chaine vide
3 std::string s3; // Création d’une chaine vide
Journée 1 Chiheb Ameur ABID 37/ 68
Les nouveautés du langage C++11/C++17

Initialisation uniforme

Initialisation uniforme
å Initialisation des agrégats
Z Tableaux
1 int arr[] { 1, 2, 3, 4 };
ID
2
r AB
float numbers[] = { 0.1f, 1.1f, 2.2f, 3.f, 4.f, 5. };
3
Chiheb Ameur u
int nums[10] { 1 }; // 1, puis des 0s
e ABID
Z Structures b Am
ih e
1 struct CarInfo { Ch
2 std::string name;
3 unsigned year;
4 unsigned seats;
5 double power;
6 };
7 CarInfo any; // Des valeurs aléatoires pour les membres de types primitifs
8 CarInfo empty{}; // 0 pour les membres de types primitifs
9 CarInfo firstCar{"Megane", 2003, 5, 116 };
10 CarInfo partial{"unknown"}; // Les autres champs prennent la valeur 0
11 CarInfo largeCar{"large car", 1975, 10};
Journée 1 Chiheb Ameur ABID 38/ 68
Les nouveautés du langage C++11/C++17

Initialisation uniforme

Initialisation uniforme
å Initialiser les objets
ID
Type objet {...};
r AB
Chiheb Ameur u
e ABID
å Am l’ordre suivant :
L’initialisation d’un objet est effectuéebselon
ih e
Ch
¶ Les constructeurs à liste d’initialisation utilisant un paramètre de type
std::initializer_list<T>
· Les autres constructeurs
¸ L’affectation directe des membres : n’est autorisée que pour les tableaux et les classes
si toutes les variables (non statiques) sont publiques et que la classe n’a pas de
constructeur défini par l’utilisateur
Journée 1 Chiheb Ameur ABID 39/ 68
Les nouveautés du langage C++11/C++17

Initialisation uniforme

Initialisation uniforme d’un objet

1 struct Box { };
2 struct Product {
ID
AB
3 Product(): name{"default product"} { }
4 Product(const Box& b) : name{"box"}{ }
u r
e ABID
Chiheb Ameur
Am
5 std::string name;
6 };
e b
7 ih
8 Product p(); // Erreur : Ch d’une fonction ?
déclaration
9 Product p1; // OK
10 Product p{}; // OK
11

12 Product q(Box()); // Erreur : déclaration d’une fonction

13 Product p2{Box()}; // OK
14 Product p2{Box{}}; // OK
Journée 1 Chiheb Ameur ABID 40/ 68
Les nouveautés du langage C++11/C++17

Initialisation uniforme

Attention !!!
å Lorsque vous utilisez des initialiseurs accolés avec le mot-clé auto, il est important de faire
attention
Z Avec C++11 et C++14, l’initialisation d’une valeur unique est interprétée comme
std::initializer_list<int>
ID
Z Par contre avec C++17, l’initialisation d’une
r AB
valeur unique est interprétée comme
valeur unique Chiheb Ameur u
e ABID
m
ebA
C hih
1 /* C++11 and C++14 */
2 auto i {10}; // i est de type std::initializer_list<int> !!!
3 auto pi = {3.14159}; // pi est de type std::initializer_list<double>
4 auto list1{1, 2, 3}; // list1 est de type std::initializer_list<int>
5 auto list2 = {4, 5, 6}; // list2 est de type std::initializer_list<int>
6
7 /* C++17 */
8 auto i {10}; // i has type int
9 auto pi = {3.14159}; // pi has type std::initializer_list<double>
10 auto list1{1, 2, 3}; // error: does not compile!
11 auto list2 = {4, 5, 6}; // list2 has type std::initializer_list<int>
Journée 1 Chiheb Ameur ABID 41/ 68
Les nouveautés du langage C++11/C++17

Les énumérations typées

Les énumérations typées

å En C ++ traditionnel, les types énumérés ne sont pas sûrs pour le type
Z Les types énumérés sont traités comme entiers
ID
Z Comparer directement deux types énumérés complètement différents !?
AB
1 enum Couleur {Rouge, Vert} couleur;
Chiheb Ameur e ur ABID
2 enum Forme {Rectangle, Ellipse} forme; Am
3 couleur=Rouge;
i h eb
4
5
forme=Rectangle;
Ch
if (forme==couleur) ....// Le compilateur ne signale rien

å Les énumérations typées visent à éviter ce problème

1 enum class Couleur {Rouge, Vert} couleur;
2 enum class Forme {Rectangle, Ellipse} forme;
3 couleur=Couleur::Rouge;
4 forme=Forme::Rectangle;
5 if (forme==couleur) ....// Erreur signalé par le compilateur
Journée 1 Chiheb Ameur ABID 42/ 68
Les nouveautés du langage C++11/C++17

Initialisation dans les instructions if et switch

Initialisation dans les instructions if et switch

å Fonctionnalité introduite en C++17
ID les instructions if et switch
å Permettre l’initialisation de variables directement dans
Z L’instruction if AB
Chiheb Ameur ur
e ABID
b Am
ih e
Ch

Z L’instruction switch
Journée 1 Chiheb Ameur ABID 43/ 68
Les nouveautés du langage C++11/C++17

Initialisation dans l’instruction if

1 int valeur {10};

2
3 if (int result = valeur * 2; result > 20) {
4 std::cout << "Le résultat est > 20 et vaut : " << result << std::endl;
5 } else {
6 std::cout << "Le résultat est =< à 20 et vaut :"<<result << std::endl;
7 }

ID
r AB
Chiheb Ameur u
e ABID
Initialisation dans l’instruction switch
b Am
ih e
1 #include <iostream> Ch
2 #include <cstdlib>
3 int main() {
4 srand(time(NULL));
5 switch (int i = rand() % 100; i) {
6 case 42:
7 std::cout << "La chance! Vous avez obtenu 42." << std::endl;
8 break;
9 default:
10 std::cout << "Vous avez obtenu " << i << "." << std::endl;
11 break;
12 }
13 }
Journée 1 Chiheb Ameur ABID 44/ 68
Les nouveautés du langage C++11/C++17

Liaison structurée

Présentation
å Fonctionnalité introduite en C++17
BID
Z Faciliter l’accès aux éléments individuels de l’objet
A
å Syntaxe générale
Chiheb Ameur meur ABID
1 auto [a, b, c, ...] = expression;eb
A
2 auto [a, b, c, ...] { h
expressionih };
3 auto [a, b, c, ...] ( C );
expression

å Appliquée aux types suivants

¶ Tableaux
· std::pair<> et std::tuple<>
¸ Les structures sur les membres non statiques et publiques
Journée 1 Chiheb Ameur ABID 45/ 68
Les nouveautés du langage C++11/C++17

Liaison structurée

Liaison structurée avec les tableaux

BID au nombre d’éléments dans le

å Le nombre d’identifiants doit correspondre exactement
tableau. rA
u
Chiheb Ameur
A me ABID
eb
hih
1 double myArray[3] { 1.0, 2.0, 3.0C};
2 auto [a, b, c] = myArray;
3 auto [d, e, f] {myArray};
4 auto [g, h] myArray; // Erreur de compilation
Journée 1 Chiheb Ameur ABID 46/ 68
Les nouveautés du langage C++11/C++17

Liaison structurée

Liaison structurée avec std::pair<> et std::tuple<>

å Le nombre d’identifiants doit correspondre exactement au nombre d’éléments dans les
objets BID A
Chiheb Ameur meur ABID
bA
h ihe
1
2
// Avec std::pair
std::pair<int, double>
C
maPaire = {1, 4.5};
3 auto [monEntier, monDouble] = maPaire; // Décomposition de la paire
4
5 // Avec std::tuple
6 std::tuple<int, double, std::string> monTuple = {2, 6.7, "Texte"};
7 auto [entier, dbl, texte] = monTuple; // Décomposition du tuple
Journée 1 Chiheb Ameur ABID 47/ 68
Les nouveautés du langage C++11/C++17

Liaison structurée

Liaison structurée avec les structures

å Par défaut, applicable avec les structures sont tous les membres sont publiques et non
statiques
å Pour les classes personnalisées, il y a la possibilité d’activer la liaison structurée
ID
r AB
Z En redéfinissant les modèles get<N>, std::tuple_size et
std::tuple_element Chiheb Ameur u
e ABID
A m
Z En utilisant, la fonction std::tie eb
ih
Ch
1 struct S {
2 int n;
3 std::string st;
4 float d;
5 };
6
7 S s;
8 auto [a, b, c] = s;
Journée 1 Chiheb Ameur ABID 48/ 68
Les nouveautés du langage C++11/C++17

Liaison structurée

Utilisation de std::tie
å std::tie crée un tuple de références à partir de ses arguments
Z Le tuple créé ne possède pas ses propres valeurs mais agit comme un alias pour les
variables existantes
ID
AB multiple
å Utile pour décomposer des tuples et pour l’affectation
r
Chiheb Ameur u
e ABID
b Am
ih e
1 int tab[] {0,1,2,3,4,5}; Ch
2 auto [a,b] {std::tie(tab[0],tab[3])}; // a=tab[0] et b=tab[3]
3 std::tie(tab[0],tab[3])=std::tuple{0,0}; // tab[0]=0 et tab[3]=0
4
5 struct S {
6 int n;
7 std::string st;
8 float d;
9 } o;
10 auto [a,b] = std::tie(o.n,[Link]);
11 std::tie(a,b) = std::tie(o.n,[Link]);
Journée 1 Chiheb Ameur ABID 49/ 68
Références et expressions

Plan

1 Historique et évolution du langage C++

2 Littéraux
ID
r AB
3 Les espaces de noms Chiheb Ameur u
e ABID
b Am
ih e
4 Ch
Les nouveautés du langage C++11/C++17

5 Références et expressions

6 Les attributs
Journée 1 Chiheb Ameur ABID 50/ 68
Références et expressions

Catégories d’expressioms

ID
r AB
Chiheb Ameur u
e ABID
Notion de value-ness
b Am
ih e
Ch dans exactement l’une des trois catégories suivantes :
å Chaque expression peut être classée
Z lvalue (left value)
Z prvalue (pure rvalue)
Z xvalue (valeur expirante)
å Une expression qui est une lvalue ou une xvalue est appelée une glvalue
(generalized lvalue).
å Une expression qui est une prvalue ou une xvalue est appelée une rvalue
å Chaque expression est soit une lvalue, soit une rvalue (mais pas les deux).
å La possibilité de déplacer (au lieu de copier) une valeur dépend de son type : lvalue ou
rvalue
Journée 1 Chiheb Ameur ABID 51/ 68
Références et expressions

Notion de value-ness

Lvalue
å lvalue (left value) est une expression qui :
Z Désigne une fonction ou un objet ; et
Z Possède une identité : elle occupe un emplacement identifiable en mémoire et, par
conséquent, on peut en principe prendre son adresse
D I
r AB
u
Chiheb Ameurmepouvait
Une expression lvalue est tout bceAqui
ABID
traditionnellement être à
ih e
gauche de l’opérateur d’affectation
C h

Expressions lvalue
å Les objets et fonctions nommés sont des lvalues
1 int getValue();
2 int i = 0;
3 const int j = 1;
4 i = j + 1; // i et j sont des lvalues
5 getValue(); // getValue est une lvalue [Note : pas getValue()]
Journée 1 Chiheb Ameur ABID 52/ 68
Références et expressions

Notion de value-ness

Expressions lvalue
å Pointeur déréférencé
Z Si e est une expression de type pointeur, alors *e est une lvalue
1 char buffer[] = "Hello";
2 char* s = buffer;
*s = ’a’; // *s est une lvalue ID
AB
3
4 *(s + 1) = ’b’; // *(s + 1) est une lvalue
u r
e ABID
Chiheb Ameur
å b Am
Le résultat de l’appel d’une fonction edont le type de retour est une référence lvalue est une
ih
lvalue Ch
1 std::vector<int> v = {{1, 2, 3}};
2 // int& std::vector<int>::operator[](int);
3 int i = v[0]; // v[0] is lvalue

å Un littéral de chaîne est une lvalue. Exemple : "Hello World"

å Les références rvalue nommées sont des lvalues
1 int&& i = 1 + 3;
2 int j = i; // i est une lvalue

å Les références rvalue vers des fonctions (nommées et non-nommées) sont des lvalues.
Journée 1 Chiheb Ameur ABID 53/ 68
Références et expressions

Notion de value-ness

Expressions prvalue
å Une prvalue est une expression qui :
Z Est un objet temporaire ou un sous-objet d’un objet temporaire, ou une valeur qui
n’est pas associée à un objet
ID en principe prendre son adresse).
Z N’a pas d’identité (c’est-à-dire, qu’on ne peut pas
B
A
Chiheb Ameur
m eur ABID
å Une prvalue est un type spécifique de rvalue
Z Tous les prvalues sont des rvalues, A
b mais tous les rvalues ne sont pas des prvalues.
ihe et englobe les prvalues ainsi que d’autres types
Z Le terme "rvalue" est plus général
h
C pas des objets.
d’expressions qui ne désignent

Expressions prvalue
å Les objets temporaires sont des prvalues
1 std::vector<int> v;
2 v = std::vector<int>(10, 2); // std::vector<int>(10, 2) est une prvalue
3 std::complex<double> u;
4 u = std::complex<double>(1, 2); // std::complex<double>(1, 2) est une prvalue
Journée 1 Chiheb Ameur ABID 54/ 68
Références et expressions

Notion de value-ness

Expressions prvalue
å Un appel de fonction dont le type de retour n’est pas un type de référence est une
prvalue
1 int func();
2 int i = func(); // func() est une prvalue
ID
r AB
å Tous les littéraux sauf les littéraux
Chihebde chaîne
Ameur u
esontABID
des prvalues
Am
double pi = 3.1415; // 3.1415 esteb une prvalue
1
ih
2
3
int i = 42; // 42 est une prvalue
Ch
i = 2 * i + 1; // 2 et 1 sont des prvalues
4 char c = ’A’; // ’A’ est une prvalue

å Le résultat produit par certains opérateurs intégrés (par exemple, +, -, *, /) est une
prvalue
1 int i, j;
2 i = 3 + 5; // 3 + 5 est une prvalue
3 j = i * i; // i * i est une prvalue

å Le mot-clé this est une expression prvalue.

Journée 1 Chiheb Ameur ABID 55/ 68
Références et expressions

Notion de value-ness

rvalue et lvalue
å lvalue (left value) : référence sur une variable (dans la pile) ou un espace alloué
dynamiquement (dans le tas) doté d’une adresse BI
D
r A
Z Tout ce qui pouvait traditionnellement
Chiheb Ameur u
eêtre ABID
à gauche de l’opérateur d’affectation
Am
å rvalue (right value - prvalue depuisebC++11) : les valeurs (ie. contenus) que l’on peut
ih
mettre dans une lvalue Ch
Z Ces valeurs peuvent très bien être retournées par une fonction
Z Une valeur n’a pas d’adresse
å Il est possible de transformer une lvalue en une rvalue à l’aide de la fonction std::move
Z std::move ne déplace rien, juste elle effectue une sorte de casting (conversion)
Journée 1 Chiheb Ameur ABID 56/ 68
Références et expressions

Notion de value-ness

Les références ID
AB
Chiheb Ameur eur
å Les références sont des alias d’objets ou de fonctions
ABID
déjà existants
å Am et rvalue0, alors il existe deux types de
Comme il existe deux types de valeursb(lvalue
références ih e
Ch
¶ les références lvalue, denotées par &, tel que &x, sont des références de lvalues.
· les références rvalue, denotées par &&, tel que &&x, sont des références de rvalues
Journée 1 Chiheb Ameur ABID 57/ 68
Références et expressions

Inférence de type

Inférence de type avec le mot clé auto

å Le mot clé auto permet de déduire automatiquement le type d’un objet lors de sa
définition à partir du type de l’objet utilisé pour l’initialisation
1 auto f = fonctionRenvoyantUnType(toto);
ID
2 auto g=1; //int g=1;
r AB
Chiheb Ameur u
e ABID
Z Utile pour éviter les répétitions
b Am
e
1 LaClasse * p=new LaClasse; hih
2 auto c2=new LaClasse; C

Z Utile pour éviter d’avoir à construire un nom compliqué lié à l’usage des templates
1 vector<vector<int> > v;
2 // C++98 (sans auto)
3 for (vector<vector<int> >::iterator
4 i=[Link](); i!=[Link]();++i)
5 // C++11
6 for (auto i=[Link](); i!=[Link]();++i)
Journée 1 Chiheb Ameur ABID 58/ 68
Références et expressions

Inférence de type

Avertissement : récupérer la value-ness

å Le mot clé auto ne permet pas de récupérer la value-ness de ce qui est à droite de
l’affectation !
1 int f1();
2 int& f2();
3 const int& f3();
ID
4
r AB
5 auto i1 {f1()}; // i1 de type int
Chiheb Ameur u
e ABID
Am
6 auto a2 {f2()}; // i2 de type int
7 auto a3 {f3()}; // i3 de type int
e b
ih
å
Ch
La value-ness est déterminée de manière manuelle
1 int & f1();
2 const int f2();
3 int f3();
4 const int & f4();
5
6 auto & i1 {f1()}; // int &
7 const auto & i2 {f1()}; //const int &
8 auto && i3 {f2()}; // int &&
9 auto && i4 {f3()}; // int &&
10 auto && i5 {f1()}; // int &
11 auto && i6 {f4()}; // const int &
Journée 1 Chiheb Ameur ABID 59/ 68
Références et expressions

Inférence de type

Inférence de type avec le mot clé decltype

å Introduit en C++11
å Le mot clé decltype permet de déduire le type y compris la value-ness d’une expression
sans l’évaluer
å Syntaxe ID
r AB
decltype(expression)
Chiheb Ameur u
e ABID
b Am
ih e
Ch
1 int i;
2 decltype(i) j {5}; // j est donc de type int
3 //////////////////////////////////////////////
4 int f1();
5 int& f();
6 const int& f3();
7
8 decltype (f1()) i1 {f1()}; //type int
9 decltype (f2()) i2 {f2()}; //type int&
10 decltype (f3()) i3 {f3()}; //type const int&
Journée 1 Chiheb Ameur ABID 60/ 68
Les attributs

Plan

1 Historique et évolution du langage C++

2 Littéraux
ID
r AB
3 Les espaces de noms Chiheb Ameur u
e ABID
b Am
ih e
4 Ch
Les nouveautés du langage C++11/C++17

5 Références et expressions

6 Les attributs
Journée 1 Chiheb Ameur ABID 61/ 68
Les attributs

Les attributs

Présentation
å Une fonctionnalité introduite avec C+11 pour fournirDdes informations supplémentaires au
I
compilateur
r AB
u
Z Optimisation du code Chiheb Ameur me ABID
Z Génération du code spécifique eb A
ih
Ch remplacer les extensions spécifiques aux compilateurs
å Les attributs ont été introduits pour
comme __attribute__ de GCC ou __declspec de MSVC depuis C++11
å Syntaxe
[[attribute]]
Journée 1 Chiheb Ameur ABID 62/ 68
Les attributs

Les attributs

Evolution
¶ C++11
Z Introduction des attributs
ID
AB
1 [[noreturn]]
2 [[carries_dependency]]
u r
e ABID
Chiheb Ameur
b Am
· C++14
ih e
Ch
Z Introduction de l’attribut [[deprecated]] pour marquer une entité obsolète
¸ C++17
Z Ajout des attributs
1 [[fallthrough]]
2 [[nodiscard]]
3 [[maybe_unused]]

Z Ignorer les attributs inconnus

Journée 1 Chiheb Ameur ABID 63/ 68
Les attributs

Les attributs

Attributs de C++11
å L’attribut [[noreturn]]
Z Une fonction ne retourne jamais comme exit() ID
r AB
Z Comportement indéfini si la fonction retourne
Chiheb Ameure u
ABID
b Am
1
ih e
[[noreturn]] void terminerProgramme() {
2
3
Ch
std::cout << "Le programme va se terminer." << std::endl;
std::exit(1); // Termine le programme avec le code de sortie 1
4 }

å L’attribut [[carries_dependency]]
Z Indiquer qu’une dépendance de données est portée à travers les appels de fonction
dans le contexte multithreadé
Journée 1 Chiheb Ameur ABID 64/ 68
Les attributs

Les attributs

Attributs de C++14
å L’attribut [[deprecated]]
ID
Z Indiquer une entité obsolète
r AB
Z Peut être accompagné d’un message
Chiheb u
e ABID
Ameurm
ebA
C hih
1 void h( int& x );
2
3 [[deprecated]] int f();
4 [[deprecated("La fonction g() est depreeiee. Utilisez plutôt la fonction h()")]] void
g( int& x );
Journée 1 Chiheb Ameur ABID 65/ 68
Les attributs

Les attributs

Attributs de C++17
å L’attribut [[maybe_unused]]
Z Supprimer les avertissements concernant les éléments inutilisés : variables,
paramètres et fonctions
ID
r AB
Chiheb Ameur u
e ABID
[[maybe_unused]] void fonctionInutilisee()b Am{
1
2 // Code qui pourrait ne pas être h ih e
appelé
3 } C
4
5 int main() {
6 [[maybe_unused]] int valeurInutilisee {42};
7 auto fonctionAvecParametreInutilise = []( [[maybe_unused]] int parametre ) {
8 std::cout << "Cette fonction pourrait ne pas utiliser son paramètre." << std::endl
;
9 };
10 fonctionAvecParametreInutilise(10);
11 return 0;
12 }
Journée 1 Chiheb Ameur ABID 66/ 68
Les attributs

Les attributs

Attributs de C++17
å L’attribut [[nodiscard]]
Z Ne pas ignorer la valeur de retour : si la valeur de retour est ignorée, le compilateur
génère un avertissement
ID
r AB
Chiheb Ameur u
e ABID
[[nodiscard]] int Amb) {
calculerSomme(int a, bint
1
ih e
Ch
2 return a + b;
3 }
4
5 int main() {
6 calculerSomme(3, 4); // Ceci va générer un avertissement
7
8 int somme = calculerSomme(3, 4); // Pour éviter l’avertissement, il faut utiliser
la valeur de retour.
9 std::cout << "La somme est : " << somme << std::endl;
10
11 return 0;
12 }
Journée 1 Chiheb Ameur ABID 67/ 68
Les attributs

Les attributs

Attributs de C++17
å L’attribut [[fallthrough]]
Z Utilisé dans les instructions switch pour indiquer explicitement qu’un case est
conçu pour tomber dans le case suivant sans interruption.

ID
r AB
1 int main() {
Chiheb Ameur u
e ABID
2 int jour {3};
b Am
3 switch (jour) {
ih e
4
5
case 1: std::cout <<
case 2: std::cout <<
Ch
"Lundi"; break;
"Mardi"; break;
6 case 3:
7 std::cout << "Mercredi";
8 [[fallthrough]]; // Indique intentionnellement qu’il n’y a pas de ’break’
9 case 4:
10 std::cout << " et jeudi aussi!";
11 break;
12 default:
13 std::cout << "Un autre jour";
14 break;
15 }
16 return 0;
17 }
Journée 1 Chiheb Ameur ABID 68/ 68
Les attributs

M ERCI POUR VOTRE ATTENTION

ID
r AB
Chiheb Ameur u
e ABID
b Am
ih e
Ch

Questions ?