Conception en C++

J'ai un projet à réaliser en C++. Comment m'organiser ? Quel stratégie adopter ? Quels sont les pièges et les erreurs à éviter ? Des questions que nous nous sommes tous posés (à moins de développer à la sauvage). Cet ouvrage répond à ces questions et à bien d'autres que peuvent se poser les développeurs, quel que soit leur niveau. C'est aussi un ouvrage de référence indispensable pour les chefs d'équipe qui pourront se servir de ce livre pour fixer les règles de développement en ayant une légitimité incontestable.
Style de conception, style de programmation, héritage, construction, destruction, idiomes (RAII, pimpl), espace de noms, module, généricité, exception, STL (conteneurs et algorithme)... Autant de points sur lesquels les auteurs nous apportent leurs conseils afin de programmation proprement, efficacement et sûrement.
Le livre est composé de 100 Articles organisés autour de 12 problématiques. Le débutant y découvrira beaucoup de choses intéressantes, rarement explicitées en cours ou dans les livres sur le langage C++, et pourra approfondir ses connaissances du développement avec le C++. L'expérimenté pourra corriger de mauvaises habitudes prises lors de son apprentissage et découvrir des pièges de sioux à éviter .
En bref, tout le monde peut trouver son compte avec cet ouvrage délivrant des conseils très pertinents, fruits de la mise en commun des expériences des grands du développement C++, pour standardiser ses codes et prendre les bons réflexes de programmation. Les articles sont agrémentés d'exemples (illustrés ou non de morceaux de codes) et d'exceptions (que serait une règle sans exception ?).

Tous les exemples proposés sont templatés, en fait à l'extrême. Dans la première partie, Alexandrescu montre ce qu'il appelle des politiques. Des politiques pour faire du code adaptable, par exemple, comment faire un smart pointer dans un cadre mono-threadé et un autre pour du multi-threads sans tout recoder et sans recompilation.
Une grande partie de l'ouvrage est dédié aux typelists et leur usage. Ces structures sont clairement expliquées, et pour une fois, on voit des applications : générer des classes héritant de plusieurs autres classes pour générer des hierarchies, des factories, ... A ce sujet, plusieurs patterns sont exposés et une implémentation type est proposée, templatée, avec des politiques à choisir et donc utilisable facilement.

De manière générale, ce livre est un très bon support à l'apprentissage correct du C++. Mais il présente l'inconvénient de supposer la connaissance préalable du C.
En effet, les concepts de base sont totalement ignorés, et les nouveautés introduites en C++ s'enchaînent. Il faut un minimum s'accrocher si l'on ne veut pas perdre pieds. Les exercices proposés en fin d'ouvrage seront un atout inestimable dans cette tâche.
Une autre particularité appréciable de ce livre est son orientation "génie logiciel". Ou comment concevoir proprement un programme, en ne faisant pas qu'exploiter à tous vas les possibilités techniques du langage, sans réfléchir à la maintenance. Plusieurs excellents conseils vont dans ce sens, répartis au fil du livre. On aurait pu en espérer un peu plus, avec peut-être plus d'exemples, et c'est ce qui m'a découragé de mettre un 4,5/5 à ce livre.
A part cela, il est en effet excellent. Autant il introduira rapidement les spécialités du C++, autant il pourra servir a posteriori d'un excellent aide-mémoire des syntaxes parfois compliquées des templates ou de l'héritage multiple. Ce qui n'est pas négligeable.
Je conseillerais cet ouvrage à tout connaisseur du C voulant débuter ou s'améliorer en C++. Il y trouvera son bonheur.
Sébastien Doeraene

Le premier chapitre permet de prendre connaissance avec le langage. A partir du deuxième chapitre on rentre dans le vif du sujet avec l'étude du constructeur et du destructeur d'un objet, les allocations mémoires etc... L'apprentissage est progressif et assorti de schémas pour compléter les explications. Le chapitre se clôture par des conseils pratiques et même un rappel sur les notions de pile d'exécution et tas d'allocation.
Le chapitre trois reprend les bases du précèdent pour définir une classe fonctionnelle et introduire le modificateur const, la surcharge des opérateurs, l'attribut statique dans une variable, une fonction et plus généralement le mot clef static. Il se conclut par des conseils pour livrer une classe, c'est-à-dire les problèmes inhérents à la compilation avec le fichier d'entête.
Le chapitre quatre étudie le concept d'héritage successivement on trouvera les classes dérivées, l'hiérarchie de classes et classe abstraite, l'héritage multiple, l'héritage virtuel. Le propos est clair progressif et agrémenté de schémas. C'est à partir de ce chapitre que la modélisation UML sera abordée.
Le chapitre cinq parle de généricité et introduit au final la notion de template. Un seul regret toutefois : les auteurs parlent de la STL mais sans l'aborder. Le chapitre six nommé « bien programmer en c++ » liste les erreurs les plus courantes et fournit des conseils pratiques pour améliorer et optimiser le code.
Enfin le chapitre sept traite de l'analyse objet à l'implémentation, ce chapitre permet de se familiariser avec les techniques de modélisations objet en utilisant le formalisme UML. Cette étude s'appuie sur la réalisation d'un petit projet de modélisation du réseau routier.
En résumé : Ce qui m'a plu : ce livre est assurément un bon choix pour les débutants tant par l'approche pédagogique basée sur l'exemple et l'enrichissement progressif des connaissances, que par les conseils prodigués au fil des pages. La présentation UML est aussi un plus ce qui est rare pour ce genre d'ouvrage. Un seul regret toutefois : l'absence d'une présentation de la bibliothèque STL.

Je m'attendais à lire un livre un peu "sec", avec des codes bruts. Cependant j'ai été agréablement surpris par les explications, la progression du niveau au cours de la lecture. Il y a vraiment un énorme pas franchi entre le moment où l'on ouvre le livre, et lorsqu'on finit le livre. Avant de le lire, je connaissais vaguement la métaprogrammation mais cet ouvrage m'a permis de découvrir des techniques et de concevoir de nouveaux types de modules à l'aide de la métaprogrammation, on peut même dire que je conçois différemment mes modules à présent. Si vous utilisez beaucoup les templates, ce livre vous plaira énormément. Pour terminet, je dirai que pour ceux qui sont habituellement assez réticents quant à l'utilisation des templates, ce livre est en quelques sortes un compromis entre des réflexions sur la conception en C++ et des utilisations mûrement réfléchies et adaptées des templates.

A réserver aux utilisateurs aguerris des templates. Ce livre est très bien fait, mais il est aussi très compliqué. La métaprogrammation n'est qu'une affaire de type, en fait. La seule chose qu'on puisse faire, c'est faire des calculs dessus. On peut faire des conteneurs de types, on peut supprimer des types, on peut empêcher l'instantiation d'un template - mais ça, c'est presque le plus facile à comprendre ! -
90% du livre est consacrer à exposer les bases de la métaprogrammation en C++. On nous montre beaucoup de choses, des itérateurs, des conteneurs, des trucs, des choses, mais on ne voit pas forcément du tout l'utilité. Celle-ci vient dans les derniers chapitres. Déjà, on parle plus de langages spécifiques à un domaine, des parseurs, des outils du genre. Et puis le seul passage qui m'a vraiment montré ce qu'on pouvait faire : Blitz++. On n'en parle pas beaucoup, mais rien que l'exemple montre qu'effectivement, c'est super puissant. Le seul problème, à mon avis, c'est que ça demande beaucoup de temps à appliquer.
Dans les appendices, on voit aussi la conformité des compilateurs avec le standard C++, le préprocesseur et Boost pour l'aider, on voit les performances du compilateur, ... Une partie est aussi consacrée aux erreurs du compilateur avec les templates et les différences entre les compilateurs. Un point intéressant est aussi les assertions statiques, donc à la compilation.
Dans l'ensemble, ce livre est LA référence de la métaprogrammation et il m'a donné de nouvelles idées à appliquer. Malheureusement, le livre reste compliqué et l'application des idées demande beaucoup de temps - et pour nous et pour le compilateur -.

Cet ouvrage destiné aux initiés commence la ou presque tous les autres livres consacrés au C++ s'arretent. Ce livre vous apprends à tirer parti de toute la puissance du langage C++. C'est le livre indispensable pour les experts ou ceux qui veulent le devenir.

Un ouvrage destiné au développeur, pour "produire plus simplement du code efficace, robuste et évolutif.". Après une étude du langage C++, les auteurs abordent la STL (Standard Template Library) en décrivant les modèles conteneur-itérateur, stratégie et adaptateur, puis les désign patterns, etc. Des références techniques, bibliographiques et multimédia complètent l'ouvrage.

Dans cet ouvrage, Scott Meyers livre au développeur C++ une mine d'informations, conseils et astuces rarement voire jamais abordés dans les livres plus classiques. Au travers de 50 astuces et règles de conception, l'auteur nous apprend à éviter les erreurs courantes, à mieux concevoir nos applications, et à construire des programmes plus robustes et efficaces. Il couvre les éléments les plus importants de la programmation objet et du C++ : gestion correcte de la mémoire, écriture de classes, principes et bonne utilisation de l'héritage.

La lecture de cet ouvrage est un réel plaisir, chaque partie se révèle riche en enseignements et conseils tous plus pertinents les uns que les autres. L'ouvrage est court (256 pages), mais l'auteur ne s'est pas arrêté là avec l'écriture d'un second volet : More effective C++ (apparemment pas encore traduit en français).

Le seul reproche qu'on pourrait faire à ce livre est son âge : il a été écrit en 1991. De ce fait, de nombreux mécanismes du C++ aujourd'hui communs sont présentés comme des améliorations futures du langage -- les templates, les exceptions et les classes imbriquées par exemple. L'ouvrage souffre également d'une non-conformité vis-à-vis de la dernière norme de 1998, et certains (rares) morcreaux de code sont à reconsidérer.

Cependant l'ouvrage s'en trouve peu affecté : l'intérêt de celui-ci est de donner des conseils et techniques d'ordre général sur la conception et les mécanisme du langage, et non des éléments de syntaxe. La quasi totalité des chapitres ne souffre donc pas de ce grand âge, et pour les quelques exceptions le lecteur pourra aisément faire la part des choses.

Comme tous les ouvrages de l'auteur, Le C++ efficace est donc un livre à posséder dans sa bibliothèque, et sera utile tout autant au débutant voulant éviter les pièges du langage qu'à l'expert souhaitant perfectionner ses connaissances.

Cette critique s'applique à la troisième édition de ce livre (Le C++ Efficace), en anglais. Le sous titre est 55 Specific Ways to Improve Your Programs and Designs. 5 éléments ont été apparemment ajoutés.
En fait, le livre a été complètement remanié, par exemple la première partie n'est plus consacrée à la migration C vers C++, mais à l'adaptation au C++ à travers les mots-clés const, les initialisations, ... La difficulté est croissante, les premiers éléments étant très simples à appréhender et à mettre en œuvre - logique, c'est l'adaptation au C++ - puis on avance vers des terrains de plus en plus minés - qu'est-ce que le compilateur crée comme fonction qu'on ne veut pas forcément, les opérateurs d'assignations, ... -. La partie sur la gestion de la mémoire gagne en complexité et s'applique à toutes les ressources, non plus seulement la mémoire. Les parties dédiées au design et déclaration des classes, leurs implémentations ainsi que l'héritage sont elles aussi pertinentes. Certains éléments des anciennes éditions ont été déplacés dans d'autres sections, d'autres éléments ont été incorporés judicieusement. Une partie dédiée à la programmation générique a été introduite, on va même jusqu'à la méta-programmation. La section consacrée à new et delete est aussi nouvelle et on parle de leur surcharge, ce qui est très intéressant.
En fait, ce livre est vraiment dédié au C++ et non à la jonction C/C++ comme par le passé. Il est même orienté vers le futur, plusieurs allusions au nouveau standard en discussion sont faites dans tout le livre avec les nouvelles classes apparues dans TR1:: et Boost. Ce livre, dans cette dernière édition, est de nouveau à la pointe, comme il l'a été lors de la première édition, après avoir marqué le pas face aux livres plus récents et plus "C++". Encore un livre à avoir dans sa bibliothèque !