book

Programmer efficacement en C++

by Scott Meyers

March 2016

Intermediate to advanced

320 pages

9h 25m

French

Dunod

Read now

Unlock full access

Conseil n° 1. Comprendre la déduction de type de template templates:déduction de typeConseil n° 2. Comprendre la déduction de type autoConseil n° 3. Comprendre decltypeConseil n° 4. Afficher les types déduits types:déduits, affichage
Conseil n° 5. Préférer auto aux déclarations de types explicitesConseil n° 6. Opter pour un initialiseur au type explicite lorsque auto déduit des types non souhaités
Conseil n° 7. Différencier () et {} lors de la création des objets objets:création avec () et {}Conseil n° 8. Préférer nullptr à 0 et à NULLConseil n° 9. Préférer les déclarations d’alias aux typedefConseil n° 10. Préférer les enum délimités aux enum non délimitésConseil n° 11. Préférer les fonctions supprimées aux fonctions indéfinies privées fonctions suppriméesConseil n° 12. Déclarer les fonctions de substitution avec overrideConseil n° 13. Préférer les const_iterator aux iteratorConseil n° 14. Déclarer noexcept les fonctions qui ne lancent pas d’exceptionsConseil n° 15. Utiliser constexpr dès que possibleConseil n° 16. Rendre les fonctions membres const sûres vis-à-vis des threadsConseil n° 17. Comprendre la génération d’une fonction membre spéciale
Conseil n° 18. Utiliser std::unique_ptr pour la gestion d’une ressource à propriété exclusiveConseil n° 19. Utiliser std::shared_ptr pour la gestion d’une ressource à propriété partagéeConseil n° 20. Utiliser std::weak_ptr pour des pointeurs de type std::shared_ptr qui peuvent pendouillerConseil n° 21. Préférer std::make_unique et std::make_shared à une utilisation directe de newConseil n° 22. Avec l’idiome Pimpl, définir des fonctions membres spéciales dans le fichier d’implémentation Pimpl (idiome)
Conseil n° 23. Comprendre std::move et std::forwardconseil n° 24. Distinguer les références universelles et les références rvalueConseil n° 25. Utiliser std::move sur des références rvalue, std::forward sur des références universellesConseil n° 26. Éviter la surcharge sur les références universellesConseil n° 27. Se familiariser avec les alternatives à la surcharge sur les références universellesConseil n° 28. Comprendre la réduction de référenceConseil n° 29. Supposer que les opérations de déplacement sont absentes, onéreuses et inutiliséesConseil n° 30. Se familiariser avec les cas d’échec de la transmission parfaite
Conseil n° 31. Éviter les modes de capture par défautConseil n° 32. Utiliser des captures généralisées pour déplacer des objets dans des fermeturesConseil n° 33. Utiliser decltype sur des paramètres auto&& pour les passer à std::forwardConseil n° 34. Préférer les expressions lambda à std::bind
Conseil n° 35. Préférer la programmation multitâche plutôt que multithreadConseil n° 36. Spécifier std::launch::async si l’asynchronisme est primordialConseil n° 37. Rendre les std::thread non joignables par tous les cheminsConseil n° 38. Être conscient du comportement variable du destructeur du descripteur de threadConseil n° 39. Envisager les futurs void pour communiquer ponctuellement un événementConseil n° 40. Utiliser std::atomic pour la concurrence, volatile pour la mémoire spéciale
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ésConseil n° 42. Envisager le placement plutôt que l’insertion

Overview

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.