Programmer efficacement en C++ : 42 conseils pour mieux maîtriser le C++ 11 et le C++ 14

Auteur(s) :

Meyers, Scott Découvrir l'auteur

Résumé

42 conseils pour mieux appréhender le langage de programmation, notamment la déduction de type, les déclarations à privilégier, les pointeurs intelligents, les expressions lambda, la sémantique de déplacement et les finitions. Des cas concrets expliqués permettent de tirer parti des ajouts du C++ 11 et du C++ 14. ©Electre 2016

Éditeur(s)
- Dunod
Date
- DL 2016
Notes
- Traduit de l'américain
Langues
- Français
- , traduit de : Anglais
Description matérielle
- 1 vol. (X-309 p.) : ill.; ; 25 cm
Titre(s) en relation
- Effective modern C++
Sujet(s)
- Programmation orientée objets (informatique)
- C plus-plus (langage de programmation)
ISBN
- 978-2-10-074391-9
Indice
- 681.229 Langages C
Quatrième de couverture
- Le C++ 11 et plus encore le C++ 14 sont des évolutions significatives du langage C++.
  Cet ouvrage vous aidera non seulement à découvrir ce qui a changé, mais aussi à écrire du code qui soit correct, efficace, facile à maintenir et à porter.
  Son objectif n'est pas de décrire ce que vous devez faire ou ne pas faire, mais de vous apporter une compréhension en profondeur du fonctionnement de C++11 et de C++14.
  Il est structuré en 42 conseils qui vous enseigneront à la fois les bonnes pratiques et les pièges à éviter.
  Vous voulez :
  
  comprendre les différentes formes de déduction de type,
  
  savoir quand (ne pas) utiliser les déclarations auto,
  
  découvrir pourquoi les fonctions membres const doivent être sûres vis-à-vis des threads,
  
  apprendre à implémenter l'idiome Pimpl avec std::unique_ptr,
  
  comprendre pourquoi éviter le mode de capture par défaut dans les expressions lambda,
  
  assimiler les différences entre std::atomic et volatile.
  
  Toutes les réponses se trouvent ici. Elles sont indépendantes de la plate-forme et conformes à la norme. Cet ouvrage présente un C++ portable.
Tables des matières
- - Programmer efficacement en C++
  - 42 conseils pour mieux maîtriser le C++ 11 et le C++ 14
  - Scott Meyers
  - Dunod
  - Avant-propos VII
  - Introduction 1
  - Chapitre 1 - Déduction de type 9
  - Conseil n° 1. Comprendre la déduction de type de template10
  - Conseil n° 2. Comprendre la déduction de type auto18
  - Conseil n° 3. Comprendre decltype23
  - Conseil n° 4. Afficher les types déduits30
  - Chapitre 2 - auto 37
  - Conseil n° 5. Préférer auto aux déclarations de types explicites37
  - Conseil n° 6. Opter pour un initialiseur au type explicite lorsque auto déduit des types non souhaités43
  - Chapitre 3 - Vers un C++ moderne 49
  - Conseil n° 7. Différencier () et {} lors de la création des objets49
  - Conseil n° 8. Préférer nullptr à 0 et à NULL58
  - Conseil n° 9. Préférer les déclarations d'alias aux typedef62
  - Conseil n° 10. Préférer les enum délimités aux enum non délimités67
  - Conseil n° 11. Préférer les fonctions supprimées aux fonctions indéfinies privées73
  - Conseil n° 12. Déclarer les fonctions de substitution avec override78
  - Conseil n° 13. Préférer les const_iterator aux iterator84
  - Conseil n° 14. Déclarer noexcept les fonctions qui ne lancent pas d'exceptions88
  - Conseil n° 15. Utiliser constexpr dès que possible95
  - Conseil n° 16. Rendre les fonctions membres const sûres vis-à-vis des threads101
  - Conseil n° 17. Comprendre la génération d'une fonction membre spéciale106
  - Chapitre 4 - Pointeurs intelligents 115
  - Conseil n° 18. Utiliser std::unique_ptr pour la gestion d'une ressource à propriété exclusive116
  - Conseil n° 19. Utiliser std::shared_ptr pour la gestion d'une ressource à propriété partagée122
  - Conseil n° 20. Utiliser std::weak_ptr pour des pointeurs de type std::shared_ptr qui peuvent pendouiller131
  - Conseil n° 21. Préférer std::make_unique et std::make_shared à une utilisation directe de new136
  - Conseil n° 22. Avec l'idiome Pimpl, définir des fonctions membres spéciales dans le fichier d'implémentation144
  - Chapitre 5 - Références rvalue, sémantique du déplacement et transmission parfaite 153
  - Conseil n° 23. Comprendre std::move et std::forward154
  - Conseil n° 24. Distinguer les références universelles et les références rvalue160
  - Conseil n° 25. Utiliser std::move sur des références rvalue, std::forward sur des références universelles164
  - Conseil n° 26. Éviter la surcharge sur les références universelles173
  - Conseil n° 27. Se familiariser avec les alternatives à la surcharge sur les références universelles179
  - Conseil n° 28. Comprendre la réduction de référence191
  - Conseil n° 29. Supposer que les opérations de déplacement sont absentes, onéreuses et inutilisées198
  - Conseil n° 30. Se familiariser avec les cas d'échec de la transmission parfaite201
  - Chapitre 6 - Expressions lambda 211
  - Conseil n° 31. Éviter les modes de capture par défaut212
  - Conseil n° 32. Utiliser des captures généralisées pour déplacer des objets dans des fermetures219
  - Conseil n° 33. Utiliser decltype sur des paramètres auto&& pour les passer à std::forward225
  - Conseil n° 34. Préférer les expressions lambda à std::bind228
  - Chapitre 7 - L'API de concurrence 237
  - Conseil n° 35. Préférer la programmation multitâche plutôt que multithread237
  - Conseil n° 36. Spécifier std::launch::async si l'asynchronisme est primordial242
  - Conseil n° 37. Rendre les std::thread non joignables par tous les chemins246
  - Conseil n° 38. Être conscient du comportement variable du destructeur du descripteur de thread253
  - Conseil n° 39. Envisager les futurs void pour communiquer ponctuellement un événement257
  - Conseil n° 40. Utiliser std::atomic pour la concurrence, volatile pour la mémoire spéciale265
  - Chapitre 8 - Finitions 275
  - Conseil n° 41. Envisager un passage par valeur pour les paramètres copiables dont le déplacement est bon marché et qui sont toujours copiés275
  - Conseil n° 42. Envisager le placement plutôt que l'insertion285
  - Index 295
Origine de la notice:
- FR-751131015