Programmer efficacement en C++

Table of contents

1. Avant-propos
2. Introduction
3. Chapitre 1. Déduction de type
   1. Conseil n° 1. Comprendre la déduction de type de template templates:déduction de type
   2. Conseil n° 2. Comprendre la déduction de type auto
   3. Conseil n° 3. Comprendre decltype
   4. Conseil n° 4. Afficher les types déduits types:déduits, affichage
4. Chapitre 2. auto
   1. Conseil n° 5. Préférer auto aux déclarations de types explicites
   2. Conseil n° 6. Opter pour un initialiseur au type explicite lorsque auto déduit des types non souhaités
5. Chapitre 3. Vers un C++ moderne
   1. Conseil n° 7. Différencier () et {} lors de la création des objets objets:création avec () et {}
   2. Conseil n° 8. Préférer nullptr à 0 et à NULL
   3. Conseil n° 9. Préférer les déclarations d’alias aux typedef
   4. Conseil n° 10. Préférer les enum délimités aux enum non délimités
   5. Conseil n° 11. Préférer les fonctions supprimées aux fonctions indéfinies privées fonctions supprimées
   6. Conseil n° 12. Déclarer les fonctions de substitution avec override
   7. Conseil n° 13. Préférer les const_iterator aux iterator
   8. Conseil n° 14. Déclarer noexcept les fonctions qui ne lancent pas d’exceptions
   9. Conseil n° 15. Utiliser constexpr dès que possible
   10. Conseil n° 16. Rendre les fonctions membres const sûres vis-à-vis des threads
   11. Conseil n° 17. Comprendre la génération d’une fonction membre spéciale
6. Chapitre 4. Pointeurs intelligents
   1. Conseil n° 18. Utiliser std::unique_ptr pour la gestion d’une ressource à propriété exclusive
   2. Conseil n° 19. Utiliser std::shared_ptr pour la gestion d’une ressource à propriété partagée
   3. Conseil n° 20. Utiliser std::weak_ptr pour des pointeurs de type std::shared_ptr qui peuvent pendouiller
   4. Conseil n° 21. Préférer std::make_unique et std::make_shared à une utilisation directe de new
   5. Conseil n° 22. Avec l’idiome Pimpl, définir des fonctions membres spéciales dans le fichier d’implémentation Pimpl (idiome)
7. Chapitre 5. Références rvalue, sémantique du déplacement et transmission parfaite
   1. Conseil n° 23. Comprendre std::move et std::forward
   2. conseil n° 24. Distinguer les références universelles et les références rvalue
   3. Conseil n° 25. Utiliser std::move sur des références rvalue, std::forward sur des références universelles
   4. Conseil n° 26. Éviter la surcharge sur les références universelles
   5. Conseil n° 27. Se familiariser avec les alternatives à la surcharge sur les références universelles
   6. Conseil n° 28. Comprendre la réduction de référence
   7. Conseil n° 29. Supposer que les opérations de déplacement sont absentes, onéreuses et inutilisées
   8. Conseil n° 30. Se familiariser avec les cas d’échec de la transmission parfaite
8. Chapitre 6. Expressions lambda
   1. Conseil n° 31. Éviter les modes de capture par défaut
   2. Conseil n° 32. Utiliser des captures généralisées pour déplacer des objets dans des fermetures
   3. Conseil n° 33. Utiliser decltype sur des paramètres auto&& pour les passer à std::forward
   4. Conseil n° 34. Préférer les expressions lambda à std::bind
9. Chapitre 7. L’API de concurrence
   1. Conseil n° 35. Préférer la programmation multitâche plutôt que multithread
   2. Conseil n° 36. Spécifier std::launch::async si l’asynchronisme est primordial
   3. Conseil n° 37. Rendre les std::thread non joignables par tous les chemins
   4. Conseil n° 38. Être conscient du comportement variable du destructeur du descripteur de thread
   5. Conseil n° 39. Envisager les futurs void pour communiquer ponctuellement un événement
   6. Conseil n° 40. Utiliser std::atomic pour la concurrence, volatile pour la mémoire spéciale
10. Chapitre 8. Finitions
    1. 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és
    2. Conseil n° 42. Envisager le placement plutôt que l’insertion
11. Index