Bien débuter en C++ (Comment résoudre les problèmes)

Bien débuter en C++

Comment résoudre les problèmes

Les problèmes auxquels sont confrontés les programmeurs sont totalement différents de ceux qu’ils devaient résoudre il y a une vingtaine d’années. Dans les années 80, les programmes traitaient des volumes importants de données brutes. Le programmeur et l’utilisateur final étaient tous deux des spécialistes de l’informatique. De nos jours, les utilisateurs sont bien plus nombreux et peu connaissent tous les détails des ordinateurs et du fonctionnement des programmes. L’utilisateur final actuel recherche des solutions prêtes à l’emploi et capables d’effectuer des opérations de gestion courantes ou ponctuelles.
L’informatique est devenue plus conviviale, mais ce processus a également conduit à la mise en œuvre de programmes de plus en plus complexes. Dans les années 70, les utilisateurs étaient contraints de saisir des commandes énigmatiques pour voir défiler à l’écran des volumes impressionnants de données brutes. Cette époque est révolue ! Une application se compose désormais de fenêtres, de menus et de boîtes de dialogue intégrés à une interface conviviale.
Avec le développement du Web, les ordinateurs ont abordé une ère nouvelle de pénétration du marché ; les utilisateurs d’ordinateurs sont plus nombreux que jamais, et ils sont très exigeants.
Au cours des dernières années, les applications se sont également étendues à d’autres périphériques : l’ordinateur de bureau n’est plus la seule cible des applications. Les téléphones portables, les assistants personnels (PDA), les PC de poche et autres périphériques constituent des cibles toutes trouvées pour les applications modernes.
Depuis la première édition de ce livre, les programmeurs ont répondu aux demandes des utilisateurs et les programmes sont devenus plus volumineux et plus complexes. La nécessité de développer des techniques de programmation permettant de gérer cette complexité est devenue évidente.
Les besoins changeant, les techniques et les langages évoluent également pour aider les programmeurs à gérer la complexité des demandes. Dans cet ouvrage, nous nous concentrerons uniquement sur une partie essentielle de cette évolution : le passage de la programmation procédurale à la programmation orientée objet.

La programmation procédurale, structurée et orientée objet

Il y a quelques années encore, les programmes étaient conçus comme des suites de procédures destinées à traiter les données. Une procédure – également appelée fonction ou méthode – est un ensemble d’instructions s’exécutant l’une après l’autre. Les données et les procédures étaient totalement dissociées et le travail du programmeur consistait à connaître les fonctions appelées par d’autres fonctions et les données qui étaient modifiées. Pour faire face à ce niveau de complexité, on a donc inventé la programmation structurée.
Le principe général de la programmation structurée consiste à diviser pour mieux régner. Un programme peut alors être considéré comme un ensemble de tâches. Toute opération trop complexe pour être décrite simplement est décomposée en un ensemble d’opérations plus simples, jusqu’à n’obtenir que des tâches suffisamment triviales pour être aisément compréhensibles.
Le calcul du salaire moyen de chaque employé d’une entreprise est, par exemple, une tâche assez complexe. Toutefois, il est possible de diviser le traitement en plusieurs tâches secondaires :
1. Compter le nombre d’employés.
2. Déterminer le revenu de chaque employé.
3. Faire le total de tous les salaires.
4. Diviser cette valeur par le nombre d’employés.
La troisième étape (total des salaires) peut également se diviser en tâches plus simples :
1. Lire l’enregistrement de chaque salarié.
2. Extraire le salaire de chaque employé.
3. Ajouter cette valeur au total général.
4. Accéder à l’enregistrement suivant.
La lecture de chaque enregistrement peut, de la même façon, être décomposée en opérations plus élémentaires :
1. Ouvrir le fichier des employés.
2. Rechercher le bon enregistrement.
3. Lire les données.
La programmation structurée résout des problèmes complexes de manière très fiable.
Toutefois, à la fin des années 80, cette méthode a montré ses limites.
D’une part, il est naturel d’associer les données (les enregistrements des employés, par exemple) et leur traitement (tri, modification, etc.). Malheureusement, la programmation structurée sépare les données des fonctions qui les manipulent et ne propose pas de moyen naturel de les regrouper. La programmation structurée est donc souvent désignée par le terme de programmation procédurale, car elle met l’accent sur les procédures (plutôt que sur les objets).
D’autre part, les programmeurs devaient souvent réutiliser des fonctions. Or, certaines fonctions qui convenaient à un type de données ne pouvaient pas toujours être réutilisées avec d’autres, ce qui limitait leurs avantages.

La programmation orientée objet (POO)

La programmation orientée objet (POO) répond à ces besoins. Elle fournit les techniques permettant de traiter des applications très complexes, exploite des composants logiciels réutilisables et associe les données aux tâches qui les manipulent.
La caractéristique essentielle de la programmation orientée objet est de modéliser des « objets » (c’est-à-dire des concepts) plutôt que des « données ». Ces objets peuvent être des éléments graphiques affichables, comme des boutons ou des zones de liste, ou des objets réels, comme des clients, des bicyclettes, des avions, des chats ou de l’eau.
Les objets possèdent des caractéristiques, également appelées propriétés ou attributs, comme âge, rapidité, volume, noir, humide. Ils ont aussi des fonctionnalités, appelées opérations ou fonctions, comme accélérer, voler, miauler ou couler. Le rôle de la programmation orientée objet est de représenter ces objets dans le langage de programmation.

C++ et la programmation orientée objet

Le langage C++ permet d’utiliser toutes les possibilités de la programmation orientée objet, notamment ses trois piliers que sont l’encapsulation, l’héritage et le polymorphisme.

Encapsulation

Un technicien ne fabrique pas les composants qu’il assemble. Il les choisit selon leurs spécifications sans se préoccuper de leur fonctionnement interne.
L’autonomie d’un objet est une propriété résultant d’un processus appelé encapsulation. Celle-ci permet de masquer les données internes d’un objet et de l’utiliser sans connaître les détails de son fonctionnement, exactement comme vous utilisez votre réfrigérateur sans comprendre le principe des compresseurs. Il reste possible de modifier ce fonctionnement interne sans affecter celui du programme, à condition toutefois que les spécifications soient respectées (le compresseur du réfrigérateur peut être remplacé par un autre de conception similaire).
Lorsque notre technicien veut utiliser un composant électronique, il n’a pas besoin d’en connaître les rouages internes. Toutes les propriétés de ce composant sont encapsulées dans l’objet composant, elles ne sont pas communiquées au circuit monté. Il n’est pas nécessaire de connaître le fonctionnement du composant pour l’utiliser efficacement. Ce fonctionnement est masqué par son boîtier.
Le langage C++ gère l’encapsulation à l’aide de types définis par l’utilisateur : les classes. Pour en savoir plus sur la conception d’une classe, reportez-vous au Chapitre 6. Si elle est correctement définie, une classe agit comme une entité encapsulée – elle fonctionne comme un composant autonome. Comme pour un objet du monde réel, son fonctionnement interne peut être masqué. Les utilisateurs d’une classe bien conçue n’ont pas besoin de savoir comment elle fonctionne, mais uniquement comment l’utiliser.

Héritage et réutilisabilité

Lorsqu’ils souhaitent concevoir une nouvelle voiture, les ingénieurs de Superauto ont le choix entre monter un projet à partir de zéro et modifier un modèle existant. Le modèle Pipo est peut-être parfait pour la ville, mais cette voiture manque de nervosité sur auto-route. Les ingénieurs ont donc décidé de lui adjoindre un turbo-compresseur et une boîte à six vitesses. Le responsable du projet préfère donc partir d’un modèle existant, le perfectionner, le tester, et l’appeler Star. La Star sera donc une sorte de Pipo, mais il s’agira d’une version spéciale, disposant de nouvelles fonctionnalités.
Le langage C++ implémente la notion d’héritage. Grâce à l’héritage, vous pouvez déclarer un nouveau type à partir d’un type existant. On dit que la sous-classe obtenue dérive du type existant ; on la nomme quelquefois « type dérivé ». Si la Star est dérivée de la Pipo et hérite donc de toutes ses qualités, certaines propriétés peuvent lui être ajoutées, d’autres modifiées. Pour en savoir plus sur l’héritage et son application en C++, reportez-vous aux Chapitres 12 et 16.

● Pourquoi choisir le langage C++ ?
● Les étapes du cycle de développement d’un programme
● Écrire, compiler et lancer votre premier programme C++