URL: https://linuxfr.org/news/nous-avons-lu-pour-vous-embracing-modern-c-safely
Title: Nous avons lu pour vous : Embracing Modern C++ Safely
Authors: Julien Jorge
 small_duck, Lawless, alkino, pulkomandy, serge_sans_paille et Ysabeau 🧶
Date: 2022年08月19日T18:26:32+02:00
License: CC By-SA
Tags: c++14, c++, livre_technique et c++11
Score: 27
_Embracing Modern C++ Safely_ par John Lakos, Vittorio Romeo, Rostislav Khlebnikov, et Alisdair Meredith, est un livre couvrant les nouveautés apportées au langage C++ dans ses versions 11 et 14. Les auteurs sont tous employés de Bloomberg et présentent chaque addition au langage sous couvert de l’expérience qu’ils en ont eu au quotidien dans leur métier.
----
[La page officielle du livre.](https://emcpps.com)
[Une présentation du livre par Vittorio Romeo - CppCon21](https://www.youtube.com/watch?v=6-1LNGWgy1o)
----
# Présentation des auteurs
John Lakos travaille depuis 20 ans chez Bloomberg, en tant que chef d’une division qui développe des composants C++ de base utilisés en interne. Il participe régulièrement à des conférences sur le C++, et fait partie du comité de normalisation du C++.
Vittorio Romeo, Rostislav Khlebnikov, et Alisdair Meredith sont tous trois développeurs senior chez Bloomberg. Le premier s’investit énormément dans la communication autour du C++ et fait de nombreuses présentations très pédagogiques sur ce sujet. On en trouvera des enregistrements sur [sa page YouTube](https://www.youtube.com/channel/UC1XihgHdkNOQd5IBHnIZWbA). John Lakos, Vittorio Romeo et Alisdair Meridith sont aussi auteurs ou co-auteurs de nombreuses propositions soumises au comité décidant des évolutions du standard C++.
Bloomberg est une gigantesque multinationale de la finance de 15 000 employés, spécialisée dans la centralisation et la publication de données financières, comme les cours de bourse, les nouvelles financières, les informations sur les entreprises. Leur produit phare est le « terminal Bloomberg », autrefois du matériel spécialisé mais aujourd’hui une simple application qui tourne sur un PC, et qui ressemble furieusement à un super-minitel. Bloomberg est donc connecté à la grande majorité des places financières de la planète, et redistribue les données en temps réel ou permet des requêtes historiques.
Ils sont connus dans le métier pour avoir une énorme base de code en C++. Ils sont également connus dans le métier pour avoir une base de code plutôt ancienne avec beaucoup de code pas franchement à la pointe de la modernité, ce qui explique certainement l’intérêt de nos quatre auteurs à soutenir les bonnes pratiques et à évangéliser une approche moderne et sûre.
# Pourquoi un livre sur C++14 en 2021?
Les standards C++11 et 14 ne sont plus tout récents, les versions 17 et 20 sont déjà disponibles.
Cependant, l’objectif de ce livre est de fournir un retour d’expérience après avoir vraiment pratiqué la programmation C++ avec ces fonctionnalités en long, en large et en travers.
Cela a donc nécessité l’implémentation des fonctionnalités dans un compilateur, le déploiement de ce compilateur dans un environnement de production, puis encore quelque temps pour la prise en main et l’utilisation des fonctionnalités et la découverte des problèmes qui peuvent survenir lors d’une utilisation réelle, hors d’exemples souvent simplistes fournis dans la documentation existante.
# Contenu du livre
[Andrei Alexandrescu](https://fr.wikipedia.org/wiki/Andrei_Alexandrescu), auteur de nombreux livres sur le C++, l’explique très bien dans la préface : ce livre est avant tout un diff du C++98 avec le C++14. Ce n’est donc ni un tutoriel, ni un recueil des meilleures pratiques de programmation, et il contient finalement assez peu de conseils. Au lieu de cela, c’est un inventaire exhaustif des nouvelles fonctionnalités du langage, expliquées et décortiquées, en particulier à travers le prisme de la sécurité.
Pour chaque fonctionnalité, le livre explique en détail son fonctionnement, puis fournit des cas courants d’utilisation, les erreurs à éviter, et enfin les cas particuliers gênants à connaître. Parfois, une annexe est ajoutée à la fin de la section pour décrire un concept plus en détail. 
Il ne s’agit donc pas d’un livre pour apprendre le C++, il s’adresse plutôt aux personnes qui connaissent déjà le langage. Par exemple, il peut servir de référence à quelqu’un qui devrait rédiger des règles de style pour une entreprise et décider de la « bonne » façon d’utiliser ou pas ces fonctionnalités. Les auteurs ont constaté que les règles appliquées chez Bloomberg ou dans d’autres entreprises étaient parfois arbitraires, basées sur les préférences personnelles de la personne qui les a rédigées, où parfois basées sur des problèmes obsolètes (bug dans une ancienne version d’un compilateur).
Avec ce livre, on dispose de toutes les raisons pour ou contre l’utilisation de chaque fonctionnalité du langage, ce qui permet d’établir des règles à partir de critères moins subjectifs.
Le livre est énorme. Pas loin de 1 400 pages pour 18,5 <span class="naked_sign">×</span><span class="naked_aural">ばつ</span> 23 <span class="naked_sign">×</span><span class="naked_aural">ばつ</span> 5 cm ; il pèse plus de deux kilos. L’intérieur est aéré, bien lisible, et les exemples de code sont bien intégrés et légers.
Le contenu du livre est organisé d’une manière ingénieuse, en trois grandes parties regroupant chacune des fonctionnalités du langage considérées sûres, variablement sûres, et risquées. Il faut entendre le terme « sûr » comme une indication de la réponse à la question « si j’utilise la fonctionnalité X, risquerai-je d’avoir de mauvaises surprises ? ». Les mauvaises surprises pouvant aller de « le code est plus compliqué à maintenir » à « certains cas sont _undefined behavior_ ou crashent ».
L’un des auteurs (Romeo) propose également d’utiliser cette classification pour enseigner le C++. Les deux premières catégories peuvent être expliquées dans une formation de base sur C++ : la première sans conditions, la deuxième en prenant soin d’expliquer où se trouvent les pièges potentiels. Les fonctionnalités rangées dans la troisième catégorie seront à réserver à des besoins très spécifiques, à des programmeurs plus expérimentés, et méritent chacune une formation ou un atelier spécifique pour bien les comprendre et les utiliser correctement.
La section des fonctionnalités sûres liste : les [attributs](https://en.cppreference.com/w/cpp/language/attributes) — [les `>` consécutifs](https://en.cppreference.com/w/cpp/language/angle_bracket_hack) — [`decltype`](https://en.cppreference.com/w/cpp/language/decltype) — les fonctions marquées [`default`](https://en.cppreference.com/w/cpp/language/function#Function_definition) — [la délégation de constructeurs](https://en.cppreference.com/w/cpp/language/constructor#Delegating_constructor) — les fonctions marquées [`delete`](https://en.cppreference.com/w/cpp/language/function#Function_definition) — les opérateurs [`explicit`](https://en.cppreference.com/w/cpp/language/cast_operator) — l’utilisation de [`static`](https://en.cppreference.com/w/cpp/language/storage_duration#Static_local_variables) dans une fonction — les types anonymes ou locaux en paramètres template — le type [`long long`](https://en.cppreference.com/w/cpp/language/types#long_long) — l’attribut [`[[noreturn]]`](https://en.cppreference.com/w/cpp/language/attributes/noreturn) — [`nullptr`](https://en.cppreference.com/w/cpp/language/nullptr) — [`override`](https://en.cppreference.com/w/cpp/language/override) — les [chaînes brutes](https://en.cppreference.com/w/cpp/language/string_literal) — [`static_assert`](https://en.cppreference.com/w/cpp/language/static_assert) — le [type de retour en fin de signature de fonction](https://en.cppreference.com/w/cpp/language/function) — les [littéraux unicode](https://en.cppreference.com/w/cpp/language/string_literal) — [`using`](https://en.cppreference.com/w/cpp/language/type_alias) en tant qu’alias de type — l'[initialisation de types agrégés](https://en.cppreference.com/w/cpp/language/aggregate_initialization) — les [littéraux binaires](https://en.cppreference.com/w/cpp/language/integer_literal) avec `0b` — l’attribut [`[[deprecated]]`](https://en.cppreference.com/w/cpp/language/attributes/deprecated) — le [séparateur de chiffres](https://en.cppreference.com/w/cpp/language/integer_literal) `'` — les [variables template](https://en.cppreference.com/w/cpp/language/variable_template).
Dans partie des fonctionnalités conditionnellement sûres on trouvera : [`alignas`](https://en.cppreference.com/w/cpp/language/alignas) — [`alignof`](https://en.cppreference.com/w/cpp/language/alignof) — les variables [`auto`](https://en.cppreference.com/w/cpp/language/auto) — l’initialisation avec des accolades — les fonctions ou variables [`constexpr`](https://en.cppreference.com/w/cpp/language/constexpr) — la valeur d'[initialisation par défaut des membres](https://en.cppreference.com/w/cpp/language/data_members#Member_initialization) de classes et d'unions — [`enum class`](https://en.cppreference.com/w/cpp/language/enum#Scoped_enumerations) — [`extern template`](https://en.cppreference.com/w/cpp/language/class_template#Explicit_instantiation) — les [_forwarding references_](https://en.cppreference.com/w/cpp/language/reference#Forwarding_references) — les POD généralisés — l'[héritage de constructeurs](https://en.cppreference.com/w/cpp/language/using_declaration#In_class_definition) — [`std::initializer_list`](https://en.cppreference.com/w/cpp/utility/initializer_list) — les [lambdas](https://en.cppreference.com/w/cpp/language/lambda) — l'[opérateur `noexcept`](https://en.cppreference.com/w/cpp/language/noexcept) — les enumérations opaques — [_range_ `for`](https://en.cppreference.com/w/cpp/language/range-for) — [`std::move`](https://en.cppreference.com/w/cpp/utility/move) et les [références aux rvalues](https://en.cppreference.com/w/cpp/language/reference#Rvalue_references) — la définition du [type sous-jacent](https://en.cppreference.com/w/cpp/types/underlying_type) aux énumérations — les [littéraux définis par l’utilisateur](https://en.cppreference.com/w/cpp/language/user_literal) — les [templates variadiques](https://en.cppreference.com/w/cpp/language/parameter_pack).
Enfin la section des fonctionnalités risquées liste : l’attribut [`[[carries_dependency]]`](https://en.cppreference.com/w/cpp/language/attributes/carries_dependency) — [`final`](https://en.cppreference.com/w/cpp/language/final) — les déclarations [`friend` étendues](https://en.cppreference.com/w/cpp/language/friend) — [`inline namespace`](https://en.cppreference.com/w/cpp/language/namespace#Inline_namespaces) — le spécificateur [`noexcept`](https://en.cppreference.com/w/cpp/language/noexcept_spec) — les fonctions membres marquées de [`&` ou `&&`](https://en.cppreference.com/w/cpp/language/member_functions#member_functions_with_ref-qualifier) — les [unions avec des types non triviaux](https://en.cppreference.com/w/cpp/language/union) — la [déduction automatique](https://en.cppreference.com/w/cpp/language/function#Return_type_deduction) du type de retour d’une fonction — [`decltype(auto)`](https://en.cppreference.com/w/cpp/language/auto).
Les lecteurs attentifs auront remarqué que ces listes concernent uniquement le langage C++ à proprement parler. Le livre n’aborde pas les nombreux changements dans la STL, la bibliothèque standard de fonctions qui fait également partie de la spécification du C++.
À l’heure où j’écris ces lignes, j’ai lu environ la moitié du livre. Chaque fonctionnalité est soigneusement présentée, suivie de cas typiques d’utilisation. Puis viennent les pièges éventuels et les situations ennuyeuses ou gênantes.
Par exemple, pour prendre un cas sûr, l’utilisation du mot-clé `static` dans la déclaration d’une variable locale à une fonction garantit que l’initialisation sera faite de manière atomique depuis C++11. Voici un extrait tiré du livre :
```c++
Logger& getLogger()
{
 // Même si deux threads appellent getLogger() simultanément, local est bien
 // initialisé une seule fois.
 static Logger local("log.txt");
 return local;
}
```
Pour illustrer un potentiel piège, considérons maintenant ce cas d’utilisation de `getLogger()`:
```c++
struct FileManager
{
 FileManager()
 {
 getLogger() << "Démarrage du gestionnaire de fichiers...";
 // ...
 }
 ~FileManager()
 {
 getLogger() << "Extinction du gestionaire de fichiers...";
 // ...
 }
};
FileManager& getFileManager()
{
 static FileManager fileManager;
 return fileManager;
}
```
L'ordre des premiers appels à `getFileManager()` et `getLogger()` n'a pas d'importance. Si le premier est appelé avant le second, il déclenchera la création du logger, sinon le logger aura déjà été créé. Par contre, l'ordre de destruction est important (notez que l'ordre de destruction est forcément l'inverse de l'ordre de création).
 - si `FileManager` est détruit en premier, tout se passe bien.
 - autrement, le comportement du programme est non spécifié (_undefined behavior_) car le destructeur de `FileManager` va appeler `getLogger()` qui va retourner une référence vers un objet qui n’existe plus.
Note de votre serviteur : ici le souci est lié à l’utilisation d’une variable statique dans les fonctions et non pas lié spécifiquement aux ajouts de C++11.
Au niveau des gênes, les auteurs notent à juste titre que dans le cas d’une fonction utilisée dans un contexte mono-thread, l’initialisation d’une variable locale `static` sera quand même inutilement gardée par des primitives de synchronisation, et l’appel ne pourra être `inline` (Notons que l’option `-fno-threadsafe-statics` permet de contrôler cet aspect avec GCC et Clang).
Du côté des fonctionnalités sans inconvénient, on peut noter `nullptr` qui n’a aucun piège ni ne provoque de surprise, ou encore `override`, qui améliore grandement la qualité du code et aide à éviter de nombreuses erreurs, sans qu’il soit vraiment possible de se tromper.
Enfin, s’agissant d’une première édition, le livre contient quelques menues erreurs ici et là, bénignes et qui seront sans doute remarquées par les habitués du langage. Elles pourront cependant perturber les autres lecteurs ; pour ces derniers, il vaut sans doute mieux attendre la seconde édition avant d’aborder ce livre.
# Commentaires du lecteur
## Commentaires de Julien Jorge
Cet ouvrage est un peu comme [le livre que j’écris](https://github.com/j-jorge/counting-in-cpp) mais rédigé en plus détaillé, mieux renseigné, et beaucoup plus neutre, par des gens qui en savent bien plus que moi. C’est un peu frustrant, mais je suis content qu’Embracing Modern C++ Safely existe :)
Je considère que c’est un très bon achat et je vous recommande de l’acquérir, que ce soit pour vous mettre à jour si vous n’utilisez pas encore ou à peine C++11, ou bien pour profiter de l’expérience de gens très qualifiés si vous voulez optimiser votre utilisation du langage. Chaque section est très complète et les avantages et inconvénients sont bien expliqués, avec des exemples simples.
On pourra reprocher au livre d’être un peu trop verbeux. Il n’est pas rare de lire une information, puis de la relire sous forme de code et commentaire, puis de la lire encore une fois deux pages plus loin. Le fait que le livre ait autant de pages que le standard C++14 est déjà un indicateur. Cela dit, je vous conseille de lire ce livre plutôt que le standard. Il faut noter que le livre ne couvre que les additions au langage et n’aborde pas la bibliothèque standard.
Cette verbosité est cependant un avantage pour le lecteur qui souhaite piocher dans le livre dans le désordre. En effet, chaque section est indépendante et peut être abordée directement.
Je note l’intention des auteurs d’être factuels et d’éviter tout forme d’opinion. C’est tout à fait réussi. Par exemple, dans les pièges potentiels et autres gênes, les situations sont listées simplement sans indiquer de gravité absolue ni même relative des uns par rapport aux autres. Certains de ces exemples me semblent parfois tirés par les cheveux et il m’arrive de me demander « mais qui irait faire ça ? » devant certains codes. Néanmoins, puisque les auteurs souhaitent présenter des faits, il est bien vu de leur part de présenter tous ces exemples sans discrimination.
## Commentaires de small_duck - Un ouvrage intéressant, mais un peu tardif ? ##
Je ne peux qu’applaudir l’effort et l’exhaustivité de l’ouvrage, qui reprend en détail chaque nouvelle fonctionnalité, ce que j’avais tenté de faire à mon humble niveau dans la section C++ de mon [blog](http://aubedesheros.blogspot.com/search/label/cpp). Les sections de cas d’utilisation sont certainement celles que je trouve les plus intéressantes : une nouvelle fonctionnalité, d’accord, mais à quoi ça sert, et pourquoi ? Les explications sont donc très claires, même si j’aurais justement préféré que ces sections prennent le pas sur les risques, qui à mon avis prennent trop de place dans le bouquin. Quelques conseils auraient été les bienvenus: les auteurs se bornent trop souvent à indiquer que « nous ne recommandons pas particulièrement cette fonctionnalité, juste indiquons son existence. »
La question se pose tout de même : en 2022, à qui s’adresse le livre ? À des développeurs et des développeuses chevronnés, très à la pointe dans le C++ 98, mais qui n’auraient pas ou peu fait de C++11/14 ? Avec la myriade de tutoriels, pages StackOverflow ou encore les dernières pages [Guru of the week](https://herbsutter.com/gotw/) d’Herb Sutter, quels sont les développeurs ou les développeuses qui ont attendu ce livre pour migrer leur base de code ? 
Aujourd’hui, quelqu’un cherchant un ouvrage sur le C++ moderne pourrait plutôt se laisser tenter par un livre qui irait jusqu’au dernier standard, peut-être en laissant de côté les fonctionnalités les plus obscures, avec des éléments de bibliothèque standard, peut-être dans une approche moins scolaire et plus prescriptive.
J’y trouve cependant mon bonheur, en partant du début du livre et en lisant petit à petit, pour réviser mes fonctionnalités, apprendre de nouvelles techniques que je pourrais utiliser dans mes bases de code, ou m’assurer que je les utilise correctement.
# Où trouver le livre
Plusieurs librairies proposent le livre. On trouvera une liste sur [le site officiel](https://emcpps.com). Il vous en coûtera une cinquantaine d’euros pour l’acquérir.
</div><div class="naked_ctrl">
<form action="/index.cgi/contrast" method="get" name="gate">
<p><a href="http://altstyle.alfasado.net">AltStyle</a> によって変換されたページ <a href="httpS://linuxfr.org/news/nous-avons-lu-pour-vous-embracing-modern-c-safely.md">(-&gt;オリジナル)</a>
/ <label>アドレス: <input type="text" name="naked_post_url" value="httpS://linuxfr.org/news/nous-avons-lu-pour-vous-embracing-modern-c-safely.md" size="22" /></label> <label>モード: <select name="naked_post_mode">
<option value="default">デフォルト</option>
<option value="speech">音声ブラウザ</option>
<option value="ruby">ルビ付き</option>
<option value="contrast" selected="selected">配色反転</option>
<option value="larger-text">文字拡大</option>
<option value="mobile">モバイル</option>
</select>
<input type="submit" value="表示" />
</p>
</form>
</div>