ISBN : 2-212-08917-1
|
|
Ce livre permettra aux développeurs de programmer avec rigueur et aux entreprises de rédiger la « charte de développement » pour les applications C++. Il s'adresse aussi aux développeurs désirant en savoir plus sur ce langage. Il indique les règles à suivre pour développer sans erreurs, ou pour localiser celles-ci plus rapidement. Il introduit des patterns pour traduire certains concepts absents dans le langage. De plus, il explique quelle technique est utilisée par le compilateur pour gérer l'héritage ou le polymorphisme et « comment ça marche ».
Il faut connaître le C++ pour aborder l'ouvrage. Vous trouverez facilement de très
bons ouvrages pour vous initier à ce langage. Je ne peux que vous conseiller l'
ARM (Annoted C++ Reference Manual, de B. Stoustrup
), ce document servant de référence au
comité de normalisation du langage. « La qualité en C++ » vous permettra,
par la suite, de vous perfectionner pour devenir un expert. Ainsi, vous parlerez le C++ sans accent
!
Le C++ est une évolution du langage C amenant pour le programmeur une puissance nouvelle.
L'approche objet permet de faire abstraction de beaucoup de détails répétitifs
pour ne se soucier que de l'essentiel. Lors de l'écriture d'une simple expression comme
a=b*c+d, une succession d'étapes est nécessaire à la
résolution de celle-ci. Beaucoup de concepts sont mis en oeuvre. Ceux-ci sont devenus
tellement naturels qu'il est facile d'en faire abstraction et de laisser le compilateur s'en
occuper. Il n'est pas nécessaire de les maîtriser précisément, car en
général, tous fonctionnent comme on l'imagine. Malheureusement, plus le langage
permet de s'affranchir de détails, plus ceux-ci peuvent avoir des effets pervers.
Le langage C est très proche de l'assembleur, c'est pour cela qu'il a été choisi par l'ensemble de l'industrie. Il est possible d'écrire un système d'exploitation avec le C (exemple Unix). Il existe peu de langages évolués ayant permis d'écrire un Système d'exploitation. Il n'est pas nécessaire de connaître l'assembleur pour maîtriser le C, pourtant, certains effets de bord ne s'expliquent que parce qu'il y a l'assembleur derrière le C. Il est courant de penser à l'assembleur généré lorsque l'on développe en C ; pas un assembleur particulier, mais les concepts présents dans chaque assembleur. Les notions de mémoire globale, de pile et de pointeurs doivent être maîtrisées pour écrire en C.
Pour le C++, l'abstraction est énorme. Lorsqu'on écrit en C++, on devrait toujours penser au C généré. C'est un peu le paradoxe de ce type de langage, plus celui-ci permet de s'affranchir de détails, plus il faut être capable de les maîtriser. Ce livre est fait pour vous informer sur les subtilités du C++.
Comme beaucoup de langages, l'expérience est transmise par le « bouche à oreille ». C'est cette connaissance, fruit de l'expérience, que je me propose de vous transmettre.
Mon objectif est de vous expliquer comment utiliser le langage en respectant des règles de qualité. La plupart des ouvrages vous expliquent chaque concept les uns après les autres, mais n'informent pas sur les pièges des interactions entre ces concepts.
Le C++ offre beaucoup d'outils permettant de faciliter les développements. Ceux-ci doivent être correctement utilisés pour ne pas laisser des erreurs à retardement dans vos programmes. Ce n'est pas parce que votre programme semble fonctionner, qu'il n'est pas criblé d'erreurs. Celles-ci apparaîtront lors des situations les plus gênantes. Selon la « loi de Murphy », les erreurs n'apparaissent jamais au développeur, ce sont les utilisateurs qui les rencontrent. Chacun ayant vécu cette expérience, sait qu'une démonstration ne fonctionne jamais, c'est le fameux « effet démo ». Pour vous éviter ce type de problème, je vous conseille de suivre les recommandations indiquées dans ce livre.
Négliger les points évoqués amène un comportement imprévisible de vos programmes. Si vous utilisez le C++ à tort et à travers, votre code sera inefficace, impossible à modifier et à maintenir. Il faut rédiger avec beaucoup de rigueur vos programmes pour augmenter leur robustesse et leur qualité.
La structure de ce livre reprend les différentes étapes d'un développement :
Le chapitre deux, « Conception d'implémentation », précise la bonne utilisation du langage. Quelles questions faut-il se poser pour écrire une classe et une méthode ? Après les phases de conception et de conception détaillée, il faut passer au codage. C'est une dernière chance de pouvoir vérifier la conception.
Le chapitre trois, « Patterns de programmation », indique comment traduire correctement certains concepts. Le C++ ne possède pas une traduction de tous les concepts utiles au développement. Les « Patterns de programmation » proposent une traduction validée pour combler ces manques. La conception détaillée doit tenir compte de ces traductions génériques.
Le chapitre quatre, « Autres principes de codage », renseigne sur des principes de codage qui ne sont pas des traductions de concept.
Le chapitre cinq, « Outils de debug », propose des outils pour faciliter la détection d'erreurs. La chapitre six indique l'ensemble des « Règles » à appliquer pour bien développer en C++. Ce chapitre doit servir de référence. Les explications détaillées de certaines d'entre elles, sont reportées au chapitre sept : « Description des règles ». J'ai choisi cette approche pour ne pas alourdir le chapitre de référence. Lorsque vous aurez compris les justifications des règles, vous n'aurez plus à consulter celui-ci.
Le chapitre huit, « Tests », donne la manière de vérifier une classe et ses méthodes. Ce chapitre traite des préconditions, des postconditions et des invariants. Il propose une démarche pour effectuer les tests unitaires d'une classe et les tests d'un paquet de classes.
Le chapitre neuf et dernier, intitulé « Comment ça marche » explique les techniques employées par le compilateur pour traduire votre programme, il permet de mieux comprendre les effets de bord possibles de celui-ci.
Un index, à la fin du document, permet de remonter aux différents chapitres. Si vous constatez une erreur dans votre programme, consultez l'index pour voir si celle-ci ne correspond pas à un cas déjà référencé.
La notation choisie pour représenter les relations entre les classes est celle
proposée par Rumbaugh, dans « OMT Modélisation et conception orientées
objet » de Rumbaugh. Vous trouverez en Annexe, un résumé de
cette notation.
Je voudrais remercier les personnes qui ont rendu possible la réalisation de ce livre, particulièrement mon épouse qui a supporté les nombreuses relectures du manuscrit. Tous mes remerciements à Joël Deslandes et Laurent Kurylo d'Arthur Andersen pour leurs révisions et la pertinence de leurs commentaires ainsi que tous ceux qui m'ont encouragé pour la réalisation de ce livre.
Vous pouvez me faire part de vos suggestions à l'adresse Internet suivante :
