Élisabeth diaz algorithmique et langagesthe.file.free.fr/1er-année bts ig/algorithmique_et...8...

Directrice de publication : Valérie Brard-Trigo

Les cours du Cned sont strictement réservés à l’usage privé de leurs destinataires et ne sont pas destinés à une utilisation collective. Les personnes qui s’en serviraient pour d’autres usages, qui en feraient une reproduction intégrale ou partielle, une traduction sans le consentement du Cned, s’exposeraient à des poursuites judiciaires et aux sanctions pénales prévues par le Code de la propriété intellectuelle. Les reproductions par reprographie de livres et de périodiques protégés contenues dans cet ouvrage sont effectuées par le Cned avec l’autorisation du Centre français d’exploitation du droit de copie (20, rue des Grands Augustins, 75006 Paris).

BTS Informatique de gestion 1re année

Élisabeth Diaz

Algorithmique et langages

Cours 3

Programmation en C++

Sommaire

Conseils généraux .................................................................................................................................... 5

Séquence 1 : Installation et configuration ...................................................................................... 7

Séquence 2 : Premiers programmes ................................................................................................ 15

Séquence 3 : Correction d’erreurs .................................................................................................... 23

Séquence 4 : Applications .................................................................................................................. 29

Séquence 5 : Mémento du C++.......................................................................................................... 37

8 3989 TE PA 03 �

Conseils généraux

1. Importance du cours pour l'examenCe cours est en réalité une succession d'exercices guidés afin de découvrir le langage C++ et de mettre en application quelques notions algorithmiques.

Cette mise en pratique est fondamentale pour mieux comprendre l'intérêt et le fonctionnement d'un langage de programmation. Pourquoi C++ ? C'est avant tout le langage le plus célèbre et le plus répandu. Il est aussi à l'origine de la création (directement ou simplement par inspiration) de nombreux autres langages. Vous l'avez compris, le C++ s'impose comme le standard incontournable.

À l'examen, aucun langage n'est imposé. Cependant vous aurez à passer une épreuve pratique sur machine où il faudra présenter une application, parmi 5, portant entre autre sur un langage de programmation de votre choix. Le but étant de présenter des applications diversifiées aussi bien en technologie abordée qu'en contenu, le fait de découvrir plusieurs langages est fondamental dans votre formation.

Enfin, compte tenu de la réputation du C++, il apparaît comme indispensable dans la culture de tout développeur d'applications.

2. Organisation du coursCe cours n'a pas du tout la prétention de vous apprendre le C++ (même les plus grands spécialistes qui ont 20 ans d'expérience dans ce domaine n'en ont pas fait le tour). Vous allez juste découvrir les prémisses du langage uniquement en mode console. Ce n'est donc pas à travers ces exercices que vous allez faire des applications graphiques. Cependant, en fin de séquence 1, une démarche sera donnée pour que vous puissiez vous essayer, plus tard, dans ce nouveau domaine.

Les séquences de ce cours vont vous faire découvrir l'environnement de développement ainsi que le langage. Elles sont progressives et dépendent les unes des autres : il est donc indispensable de les suivre dans l'ordre.

Il est conseillé de réaliser les séquences 1 à 3 lorsque vous connaîtrez, en algorithmique, toutes les structures de base (affectation, condition, itération...). Faites la première application de la séquence 4 lorsque vous aurez vu les tableaux, et la seconde application de la séquence 4 lorsque vous aurez vu les modules (procédures et fonctions). Un mémento du C++ est présenté en séquence 5.

Prenez le temps de lire une première fois le mémento de la séquence 5 avant de commencer à programmer. Vous aurez ensuite régulièrement recours à ce mémento.

Toutes les corrections des exercices guidés de ce cours sont téléchargeables (http://www.campus-electronique.fr/BTS-InformatiqueGestion/ puis rubrique Téléchargement)

Conseils généraux

8 3989 TE PA 03 �

Séquence 1Installation et configuration

Séquence 1

Installation et configurationCette première séquence va juste vous permettre de comprendre les étapes de configuration nécessaire pour installer le C++ et tous les outils associés. En réalité, en fin de séquence, un pack d'installation rapide vous est proposé. Cependant, une démarche plus longue est présentée pour ceux qui désirent comprendre ce qui se cache derrière un pack, quel que soit le langage.

u Capacités attendues en fin de séquenceAvoir compris comment configurer les différents outils nécessaires pour développer dans un langage.

u Contenu1. Que doit-on installer ? .................................................................................................................8

2. Installation détaillée .....................................................................................................................9

3. Installation rapide du pack .................................................................................................... 12

� 8 3989 TE PA 03


1. Que doit-on installer ?Pour utiliser un langage, vous devez installer les outils nécessaires car l'ordinateur ne peut pas comprendre directement le langage.

Écriture du code sourceLe code source d'un programme peut être écrit dans n'importe quel éditeur (par exemple notepad). Il existe cependant des éditeurs plus évolués, qui apportent une colorisation au code (pour distinguer les mots réservés, les variables, etc.). Encore plus évolués que ces éditeurs, il existe des environnements de développement qui offrent de nombreux services (aide à la recherche d'erreurs, tests, aide à l'écriture du code...). On les appelle des IDE (Integrated Development Environment). Pour chaque langage, il existe des IDE gratuits, d'autres payants. Certains IDE sont multi-langages.

Pour le C++, il existe de nombreux IDE, les plus connus sont Visual C++ de Microsoft, Borland C++ et parmi les gratuits, entre autre devC++, Code::Blocks et Eclipse. Nous allons travailler avec ce dernier, très connu pour être un IDE pour le langage Java (vous l'utiliserez l'an prochain) mais aussi très performant pour le C++.

Transformation du code source en code exécutableUne fois le code source écrit (dans un éditeur simple ou dans un IDE), il doit subir une transformation afin d'être traduit en langage machine. Dans ce domaine, il existe 2 grandes catégories de langages.

Les langages compilés : le code source doit d'abord subir une étape de compilation, puis de link avant de pouvoir être exécuté (le compilateur est un programme qui traduit le code source en code machine et crée un fichier que l'on appelle fichier "objet", le link permet ensuite de faire le lien entre ce code source et les éventuelles bibliothèques externes utilisées, après le link, on obtient ce qu'on appelle un fichier exécutable, généralement avec l'extension exe). Un programme écrit dans un langage compilé ne pourra être exécuté que lorsqu'il a passé les étapes de compilation et de link. Tant qu'il contient des erreurs syntaxiques ou sémantiques, l'exécutable ne se crée pas.

Les langages interprétés : ils sont traduits en langage machine et exécutés "à la volée" c'est à dire ligne par ligne, au fur et à mesure de l'exécution. Dans ce cas, le programme peut contenir des erreurs et tout de même s'exécuter, tant qu'il ne tombe pas justement sur cette erreur.

C++ est un langage compilé. Il faudra donc installer le compilateur nécessaire.

Exécution du codeUne fois le fichier exécutable créé, il est possible de le lancer directement. Les IDE proposent généralement aussi une possibilité d'exécution directement dans l'environnement.

Attention, parfois un fichier exécutable ne se suffit pas à lui même et fait appel à des fichiers annexes (comme des bibliothèques externes). Lorsque vous voulez transporter votre programme sur une autre machine, il faut alors prévoir de prendre tous les fichiers nécessaires. Certains IDE proposent la création d'un "installeur", donc d'un programme qui va permettre de regrouper tous les fichiers nécessaires et de les copier correctement sur un nouvel ordinateur. Vous avez l'habitude d'utiliser des installeurs à chaque fois que vous installez une nouvelle application sur votre ordinateur.

8 3989 TE PA 03 �


2. Installation détailléePour utiliser le C++ avec l'IDE Eclipse, vous devez installer les outils suivants :

• MinGW : le compilateur du langage

• Eclipse pour le C++ : l'IDE

• GDB : le débuggeur

• Qt : pour les applications graphiques

Cette partie va détailler les étapes d'installation de ces différents outils. Vous pouvez suivre ces étapes pour mieux comprendre le rôle de chaque outil. Cependant, il est possible qu'au final vous rencontriez des difficultés. En effet, au moment où vous téléchargerez les outils nécessaires, les versions auront évolué et il arrive parfois qu'il y ait des incompatibilités. Au final, même si vous suivez correctement les étapes, il est tout de même conseillé de travailler avec le pack qui vous est fourni, et qui est présenté dans la partie 3 "installation rapide du pack". Cette partie 2 est donc dans un premier temps plutôt présentée comme de la culture générale et, pour la suite, pour ceux qui veulent se lancer dans la programmation graphique.

Voici donc les étapes d'installation de chaque outil.

MinGWMême en utilisant un IDE, il faut généralement au préalable installer le compilateur qui va se charger de traduire le code source en code machine.

Il existe plusieurs compilateurs pour le C++, différents sous chaque système d'exploitation. Nous allons utiliser mingw qui est un des plus répandus sous Windows.

Suivez pas à pas les étapes d'installation de mingw.

Récupération de mingw

Allez sur le site de mingw (http://www.mingw.org/).

Dans le menu de gauche, choisissez downloads.

Dans la nouvelle page, prenez mingw 5.1.4 (version récupérée au moment de la création de ce tp) ou la dernière version. Adresse de récupération directe : http://sourceforge.net/project/downloading.php?group_id=2435&filename=MinGW-5.1.4.exe&a=6620096

Installation de mingw

Une fois le fichier récupéré, lancez-le.

1re fenêtre de bienvenue, faites directement next.

2e fenêtre : vous pouvez décider de télécharger et installer en même temps ou juste de télécharger. Prenez plutôt la première option et cliquez sur next.

3e fenêtre, licence classique : cliquez sur "I agree".

4e fenêtre, 3 choix possibles, prenez le choix par défaut (Current) puis next.

5e fenêtre, choix des composants. Le premier est sélectionné par défaut. Prenez aussi le second (g++ compiler), puis next.

6e fenêtre : choix du chemin d'installation. Surtout ne changez pas le chemin par défaut. Faites next.

7e fenêtre, pour le Start Menu Folder, là encore gardez plutôt le choix par défaut, puis install.

Le download commence. Quand il arrive à "completed", cliquez sur next.

Dernière fenêtre, il ne reste plus qu'à cliquer sur finish.

10 8 3989 TE PA 03


Modification du path pour le compilateur

Pour que le compilateur soit pris en compte, il faut modifier le path :

Clic droit sur le poste de travail, sélectionnez propriétés.

Onglet "avancé", cliquez sur "variables d'environnement".

Dans "variables système", cliquez sur la variable "Path", puis sur "Modifier".

À la fin de la valeur de la variable, ajoutez ceci :

;C:\MinGW\bin

N'oubliez pas le ; qui permet de séparer du reste de la ligne. Ce chemin est correct que si vous avez pris le chemin d'installation par défaut. Sinon, à vous de mettre le bon chemin.

Cliquez sur ok (normalement, 3 fois ok pour fermer toutes les fenêtres).

Relancez l'ordinateur pour prendre en compte le path modifié.

Environnement Eclipse pour C++Vous allez travailler avec l'environnement Eclipse spécialement dédié au C++. Voici la procédure d'installation à suivre.

Récupération d'Eclipse pour C++ (ganymede)

Sur le site d’Eclipse, partie downloads (ww.Eclipse.org/downloads), téléchargez "Eclipse ide for c++ developers". Attention, récupérez bien la version pour Eclipse ganymede et non Eclipse galileo ou Eclipse Europa. (fichier téléchargé lors de la création de ce tp : eclipse-cpp-ganymede-SR2-win32.zip)

Installation d'Eclipse

Eclipse ne s’installe pas, il suffit de le dezipper où vous voulez.

Une fois le dossier dezippé, entrez dedans et lancez Eclipse.exe.

Au démarrage, une fenêtre s’ouvre demandant le chemin des projets : il est conseillé de créer, à l’endroit où vous voulez sur le disque, un dossier dans lequel tous vos projets seront copiés. Une fois le dossier créé, donnez le chemin de ce dossier et cliquez sur ok.

Lors du premier démarrage, la page d’accueil présente plusieurs cercles : cliquez sur celui de droite (avec la flèche) pour accéder à la zone de travail d’Eclipse.

Test

Une fois Eclipse lancé, créez un nouveau projet (file/new/c++ project).

Donnez un nom au projet (par exemple essai), sélectionnez "empty project" puis cliquez sur finish.

À gauche, dans "project explorer", sélectionnez votre projet. Vous allez créer un fichier source pour insérer du code : file/new/source file. Dans la fenêtre, comme nom de fichier, tapez "essai.cpp" (sans oublier l’extension cpp) puis cliquez sur finish.

Dans la partie centrale, un fichier s’est ouvert avec juste un début de commentaires. Supprimez tout et tapez le code suivant :

#include <stdio.h>int main () { printf("coucou") ; return 0 ;}

Sauvez (avec ctrl-S). Remarquez que la petite étoile qui était à côté du nom du fichier, dans l’onglet, a disparu (cela prouve que le fichier est sauvé).

8 3989 TE PA 03 11


Pour compiler et linker le projet, dans project explorer (à gauche) sélectionnez le projet, puis faites "project/build all".

Contrôlez que le fichier exécutable a été créé en allant directement dans le dossier de votre projet, sur le disque, et dans le sous dossier debug. Vous devriez trouver le fichier "essai.exe". Lancez ce fichier. Une fenêtre s'ouvre et se referme aussi vite : c'est normal, juste après avoir affiché "coucou", la fenêtre se ferme car le programme est terminé. Revenez dans Eclipse et cette fois, toujours après avoir sélectionné le projet dans la colonne de gauche, cliquez sur la flèche blanche dans le rond vert (en haut). Remarquez en bas, dans l'onglet "console", le mot "coucou" s'est affiché.

Si les étapes précédentes se déroulent comme elles sont décrites, c'est que toute l'installation (mingw et Eclipse) s'est bien passée.

Débuggeur GDBIl est possible d'associer un débuggeur à un compilateur. Ce n'est pas une obligation mais ce genre d'outil apporte une aide non négligeable pour la recherche d'erreurs.

Récupération de GDB

Fichier récupéré au moment de la réalisation de ce tp : gdb-6.8-mingw-2.tar.bz2 (lien direct de téléchargement : http://downloads.sourceforge.net/mingw/gdb-6.8-mingw-3.tar.bz2?modtime=1208982015&big_mirror=1).

Vous trouverez ce fichier sur le site sourceforge.net.

Installation de GDB

GDB ne s'installe pas. Dézippez le contenu : vous allez obtenir un nouveau fichier compressé. Le contenu de ce nouveau fichier doit être dezippé directement dans le dossier c:\MinGw afin que les fichiers se positionnent directement dans les bons dossiers.

Qt pour l'environnement graphique

O Ne réalisez les étapes de cette partie que lorsque vous aurez fini ce cours. En effet, vous n'aurez pas à utiliser l'environnement graphique dans ce cours, car pour cela il faut des notions en programmation objet, que vous ne connaissez pas encore.

Si par la suite vous avez envie de vous lancer dans de la programmation graphique, alors voici les étapes pour installer les bibliothèques nécessaires.

Installation de Qt

Fermez Eclipse.

Qt se chargeant d’installer sa version de mingw, désinstallez mingw (en passant par le uninstall du menu mingw dans demarrer) et supprimez le dossier qui se trouve en racine de C.

Sur le site de Qt (www.qtsoftware.com), partie downloads, sélectionnez "choose LGPL free" et dowmloadez juste le framework correspondant à votre système (lien direct : http://get.qtsoftware.com/qt/source/qt-win-opensource-4.5.2-mingw.exe)

Téléchargez la version qui correspond à votre système.

Lancez l’installation et suivez les étapes en gardant les options par défaut, sauf arrivé à l’écran de mingw : demandez de l’installer et suivez les étapes.

Pour que Qt soit pris en compte, il faut aussi modifier le path, comme vous l’avez fait précédemment pour le compilateur, mais cette fois en intégrant le chemin du dossier bin de Qt (normalement : C:\Qt\4.5.2\bin).

12 8 3989 TE PA 03


Intégration de Qt à Eclipse

Sur le site de Qt (www.qtsoftware.com), partie downloads, sélectionnez "Qt Eclipse Integration" dans la partie "other downloads" (lien direct :

http://www.qtsoftware.com/developer/Eclipse-integration)

Téléchargez la version qui correspond à votre système.

Lancez le fichier téléchargé et suivez les étapes (attention, un des écrans demande le chemin d’Eclipse et de mingw/bin : donnez les bons chemins car ceux proposés par défaut ne sont pas toujours corrects).

Il faut maintenant configurer Qt sous Eclipse. Lancez Eclipse, allez dans Window/Preferences. Dans la partie gauche, sélectionnez Install/Update, et à l’intérieur, sélectionnez Qt. Cliquez sur Add, renseignez les 3 zones (en allant chercher le dossier bin dans c:\Qt, normalement la ligne include va se remplir toute seule, pensez aussi à renseigner le nom qui sert juste d’identification). Cliquez sur finish puis ok.

Test de Qt

Pour contrôler si Qt est bien installé, lancez Eclipse. Allez dans file/new/project… Si vous voyez dans la liste, Qt, c’est bon signe ! Cliquez sur le + pour ouvrir cette partie et sélectionnez "Qt gui project" puis next. Donnez un nom au projet puis cliquez sur finish.

Une fenêtre s’ouvre vous proposant d’ouvrir la perspective maintenant : cliquez sur non.

Dans la partie gauche, sélectionnez le nouveau projet, puis lancez l’exécution. Une fenêtre s’ouvre demandant le type de compilation : prenez le choix par défaut. Si tout va bien, l’exécution doit présenter une fenêtre vide. Si c’est le cas, cela signifie que tout est bien installé. Vous pouvez fermer la fenêtre.

Pour accéder aux objets graphiques, allez dans le menu Window/Show view/Other… Déroulez la partie Qt et sélectionnez "Qt c++ widget box", puis ok. Dans la partie gauche, la liste des objets graphiques apparaît. Toujours à gauche, revenez sur "project explorer" et sélectionnez le fichier portant le nom du projet, avec l’extension ui : vous devriez voir apparaître dans la partie centrale, la visualisation de la fenêtre (pour le moment vide). Insérez un objet graphique (par exemple un bouton) puis lancez l’exécution pour voir si le bouton apparaît. Vous pouvez fermer la fenêtre.

Toutes les installations et tests sont terminés pour la partie graphique. Beaucoup de code se génère automatiquement, mais il faut avoir de solides notions de programmation événementielle et objet pour développer une application graphique. Ces notions seront abordées plus tard.

3. Installation rapide du packComme cela arrive très souvent lorsque les installations comportent plusieurs outils, certains développeurs mettent au point des packs qui contiennent tout le nécessaire. C'est le cas du pack que vous allez utiliser. Ce pack contient la version Europa d'Eclipse, contrairement aux explications précédentes qui utilisaient la version Ganymede. Ne soyez pas étonné, il n'y avait tout simplement pas de pack avec Ganymede, cependant cela marche aussi très bien pour ce que l'on a à faire dans ce cours.

8 3989 TE PA 03 13


Installation du packLe pack vous est fourni (eclipsecpppack-0.1.zip) (http://www.campus-electronique.fr/BTS-InformatiqueGestion/ rubrique Téléchargement)

Il suffit de le récupérer et de le dezipper où vous voulez, sur votre disque. Le pack ne s'installe pas. Une fois dezippé, entrez dans le dossier et lancez le fichier Eclipse.bat. Eclipse s'ouvre. Tout est déjà configuré. Sur la page d'accueil, cliquez sur le rond qui contient une flèche, à droite. Vous accéder à la zone de travail d'Eclipse. Voilà c'est terminé…

TestFaisons un rapide premier test pour contrôler que tout marche bien. Avant tout, créez à l'endroit de votre choix sur votre disque, un dossier qui contiendra vos projets.

Une fois Eclipse lancé, créez un nouveau projet (file/new/c++ project). Donnez un nom au projet (par exemple essai). La case "use default location" est cochée : décochez-la et sélectionnez le dossier de projets que vous avez créé, en rajoutant à la fin "\essai" pour que dans ce dossier de projets, le dossier essai soit créé pour mémoriser le nouveau projet. Ainsi, chacun de vos projets sera mis dans un dossier spécifique. N'oubliez pas par la suite, à chaque création d'un nouveau projet, de préciser ainsi le nom du nouveau dossier. Puis, sélectionnez "empty project" dans la partie "Executable" qu'il suffit d'ouvrir en cliquant sur le +. Enfin cliquez sur finish.

À gauche, dans "project explorer", sélectionnez votre projet. Vous allez créer un fichier source pour insérer du code : file/new/source file. Dans la fenêtre, comme nom de fichier, tapez "essai.cpp" (sans oublier l’extension cpp) puis cliquez sur finish.

Dans la partie centrale, un fichier s’est ouvert, vide. Tapez le code suivant :#include <stdio.h>int main () { printf("coucou") ; return 0 ;}

O Surtout n'oubliez pas la ligne vide après la dernière accolade.

Sauvez (avec ctrl-S). Remarquez que la petite étoile qui était à côté du nom du fichier, dans l’onglet, a disparu (cela prouve que le fichier est sauvé).

Pour compiler et linker le projet, dans project explorer (à gauche) sélectionnez le projet, puis faites "project/build all".

Contrôlez que le fichier exécutable a été créé en allant directement dans le dossier de votre projet, sur le disque, et dans le sous dossier debug. Vous devriez trouver le fichier "essai.exe". Lancez ce fichier. Une fenêtre s'ouvre et se referme aussi vite : c'est normal, juste après avoir affiché "coucou", la fenêtre se ferme car le programme est terminé. Revenez dans Eclipse et cette fois, toujours après avoir sélectionné le projet dans la colonne de gauche, cliquez sur la flèche blanche dans le rond vert (en haut). Remarquez en bas, dans l'onglet "console", le mot "coucou" s'est affiché.

Ce premier test vous a permis une toute première découverte de l'environnement et un contrôle du bon fonctionnement du pack.

8 3989 TE PA 03 1�

Séquence 2Premiers programmes

Séquence 2

Premiers programmesCette séquence va être l'occasion de découvrir l'environnement Eclipse et d'écrire quelques petits programmes. C'est l'occasion aussi de se familiariser avec la syntaxe du langage C++. Pour comprendre les codes proposés, et rédiger les premiers programmes, vous utiliserez la dernière séquence de ce cours, qui contient un petit mémento du langage. Il est d'ailleurs conseillé de commencer par une première lecture de ce mémento avant d'attaquer cette séquence.

u Capacités attendues en fin de séquenceSavoir écrire et tester de petites applications. Connaître les bases de la syntaxe du langage C++ : saisie, affichage, affectation, calcul, condition, itération.

u Contenu1. Présentation d'Eclipse ................................................................................................................16

2. Test d'un programme .................................................................................................................17

3. Modification d'un programme ..............................................................................................20

4. Traduction d'un algorithme ....................................................................................................21

Synthèse ................................................................................................22

16 8 3989 TE PA 03


1. Présentation d'EclipseEclipse est un IDE complet qui offre de nombreux outils. Seuls certains seront exploités dans ce cours. Nous allons dans un premier temps présenter l'environnement global.

Dans un test précédent, vous avez déjà eu l'occasion de découvrir l'environnement. Repositionnez-vous sur ce test, ou, si vous l'avez perdu, recréez-le (en vous référant aux explications précédentes). Vous obtenez un environnement qui ressemble à ceci :

Par la suite, nous verrons comment utiliser les aides d'Eclipse pour rechercher les erreurs dans un programme.

Vous remarquerez rapidement que la zone centrale, réservée à l'écriture du code, offre de nombreuses facilités de saisies (indentations automatiques, fermeture des parenthèses et guillemets, soulignement des erreurs, colorisation…).

Pour tous les programmes qui vont être réalisés dans ce cours, prenez l'habitude de coder sous Eclipse puis de lancer directement le fichier exe, donc à l'extérieur d'Eclipse. Vous l'avez déjà fait lors d'un premier test. Le fichier exe se trouve dans le dossier debug qui est dans le dossier du projet.

Vous pourriez lancer le test par la flèche, mais certaines commandes ne s'exécutent pas dans la console : seuls les affichages simples apparaissent. La console sert normalement de zone de test. Dans une application graphique, on utilise la commande printf juste pour afficher des informations de tests dans la console.

Zone de travail : code source (colorisé)

menus

Les composants du fichier

Onglet pour afficher la console de visualisation

Exécution dans l'IDE

Les fichiers du projet

Onglet pour lister les erreurs

8 3989 TE PA 03 1�


2. Test d'un programmeVous avez eu l'occasion de réaliser un tout premier test, en voici un second juste un peu plus long.

Créez un nouveau projet et, dans ce projet, un fichier source du nom de test1.cpp. Si le fichier qui s'ouvre contient des commentaires (c'est le cas dans la version Ganymede d'Eclipse), supprimez-les. Dans ce fichier, tapez le code suivant, ligne par ligne, en prenant le temps d'observer les réactions de l'IDE et les aides apportées. Il est très important que vous observiez ce qui se passe, le but de cet exercice étant de découvrir dans un premier temps l'IDE. Même si vous ne connaissez pas encore le langage, essayez aussi de comprendre, avec les commentaires et les explications, ce que fait le programme étape par étape.

/* Jeu du nombre caché * auteur : Ed * date : 27/06/2009 */

//--- bibliothèques nécessaires ---#include <stdio.h> // pour le printf et scanf#include <conio.h> // pour le getch#include <stdlib.h> // pour le system(«cls»)

//--- programme principal ---int main () {

// déclarations int valeur, essai, nbre = 1 ;

// saisie du nombre à chercher printf("Entrez le nombre \x85 chercher =") ; scanf("%d",&valeur) ; system("cls") ;

// boucle sur la saisie des essais printf("Entrez un essai =") ; scanf("%d",&essai) ; while (essai != valeur) { if (essai > valeur) { printf("trop grand !") ; }else{ printf("trop petit !") ; } printf("\nEntrez un nouvel essai =") ; scanf("%d",&essai) ; nbre++ ; }

// résultat printf(«Vous avez trouv\x82 en %d essais», nbre) ;

getch() ; return 0 ;

}

Les étoiles du commentaire s'insèrent automatiquement à partir de la seconde ligne.

La saisie de l'accolade ouvrante crée l'accolade fermante (idem pour les guillemets)

Les indentations sont automatiques

1� 8 3989 TE PA 03


Une fois le programme écrit, sélectionnez le projet (à gauche) et compilez (Poject/Build all). À l'extérieur d'Eclipse, exécutez le programme (en allant chercher le fichier exe dans le dossier debug du projet).

Si vous ne trouvez pas le fichier exe dans le dossier debug, c'est que la compilation a trouvé des erreurs. Contrôlez votre programme et corrigez les erreurs avant de compiler à nouveau.

Au final, vous devriez obtenir une exécution qui ressemble à ceci :

Sans connaître le langage, vous avez compris la logique globale du programme : il permet de saisir une valeur à chercher, puis de boucler sur la saisie des essais d'un second joueur (d'où l'écran qui s'efface après la première saisie), chaque essai étant comparé à la valeur d'origine pour afficher un message (trop grand ou trop petit), au final le nombre d'essais nécessaires pour trouver la valeur est affiché.

Pourquoi avez-vous compris le but du programme ?

Les commentairesPlusieurs commentaires ont été placés dans le code. Il existe 2 types de commentaires :

Les commentaires sur plusieurs lignes, entourés de /* et */ : c'est la notation officielle, d'ailleurs vous avez remarqué les lignes de commentaires qui se sont construites automatiquement quand vous avez tapé /*.

Les commentaires sur une ligne ou une partie de ligne : dès que le signe // est rencontré par le compilateur, le reste de la ligne est considéré comme un commentaire. Ce système est pratique pour mettre juste un petit message de commentaire. De plus, il est plus rapide à écrire que le précédent car il ne nécessite pas une balise de fin de commentaire.

Lorsque l'on code, il faut respecter une "charte de code". Celle-ci est souvent imposée dans les entreprises, mais peut varier en contenu d'une entreprise à l'autre. Dans tout ce cours, quelques éléments de charte de code vont être utilisés pour vous apprendre à être rigoureux à ce niveau là.

Par exemple, si vous observez bien les commentaires du code, vous remarquerez qu'en réalité 4 types de commentaires ont été utilisés :

• La cartouche : bloc de commentaire en début de programme qui présente les caractéristiques du programme.

/* Jeu du nombre caché * auteur : Ed * date : 27/06/2009 */

8 3989 TE PA 03 1�


• Les commentaires de blocs et de modules : pour le moment il y a le bloc des includes et le module principal (main). Plus tard, on retrouvera ce type de commentaires en tête de chaque module (procédure ou fonction). Ici les 3 traits qui l'entourent servent juste à le mettre un peu plus en évidence.

//--- Programme principal ---

• Les commentaires de blocs de code dans un module : ils précisent le rôle des lignes de code qui le suivent.

// saisie du nombre à chercher

• Les commentaires informatifs de ligne : ils apportent une précision sur une seule ligne de code (souvent utilisé pour les déclarations).

#include <stdio.h> // pour le printf et scanf

Vous n'êtes pas obligé de suivre cette charte, cependant il est indispensable que vous en suiviez une. Gardez toujours la même façon de présenter votre code. La charte de code porte sur les commentaires, mais aussi sur les indentations et les noms de variables.

O Ne tombez pas dans l'erreur classique qui consiste à dire "je code d'abord et je commente ensuite". Un développeur écrit toujours les commentaires AVANT d'écrire le code correspondant pour 2 raisons : d'abord le commentaire aide à réfléchir sur le code que l'on doit écrire, ensuite le programme est très facile à comprendre quand il est commenté et l'on peut s'y référer sans problème. Vous ne serez jamais un vrai développeur si vous ne suivez pas cette règle.

Les indentationsLe programme est aussi facile à comprendre grâce aux indentations.

Vous avez remarqué que le code s'est spontanément indenté (gestion automatique des décalages) au fur et à mesure de la saisie. C'est l'IDE qui gère les indentations automatiques, ce qui est bien pratique. Si vous tapez votre code dans un éditeur simple, il faut alors les gérer soi-même.

Ces indentations sont indispensables pour bien comprendre le sens du code : elles permettent de repérer rapidement les imbrications entre les différentes structures. Par exemple, ici on repère la boucle générale sur la saisie des différents essais, et dans la boucle, la condition pour contrôler si l'essai est trop grand ou trop petit.

Normalement, vous avez déjà appris à indenter dans les algos. Ici, vous découvrez la charte de code au niveau règles d'indentation. En effet, il existe plusieurs méthodes d'indentations. Celle présentée ici est la plus officiellement reconnue.

Voici les règles d'indentations utilisées :

• accolade ouvrante en fin de ligne ;

• accolade fermante alignée verticalement sur le début du bloc correspondant ;

• décalages d'une tabulation ;

• "else" mis sur la même ligne entre l'accolade fermante de la partie "alors" et l'accolade ouvrante de la partie "sinon".

Vous découvrirez par la suite d'autres aspects de ces règles d'indentation et présentation du code.

20 8 3989 TE PA 03


Les noms des variablesLes noms de variables utilisés dans le programme représentent aussi une aide à la compréhension générale. Cette notion n'est pas nouvelle : vous l'avez découverte en algorithmique.

Les noms de variables doivent toujours être très explicites pour mieux les repérer dans le code. Eclipse apporte une aide supplémentaire à ce niveau là : double cliquez sur une des variables (par exemple, essai) pour la sélectionner et observez que la variable a été repérée dans tout le code. Remarquez aussi que sur la droite du code, à côté de l'ascenseur, des petites marques sont apparues : si vous cliquez sur l'une d'elles, vous êtes directement positionné sur une ligne contenant la variable. Ces petits repères, nous les retrouverons plus tard lors de la recherche d'erreurs.

Pour revenir au choix des noms de variables, pour le moment nous nous contentons de donner des noms parlants. Par la suite, vous apprendrez qu'il existe des règles de nommage : par exemple, les constantes en majuscules, les noms des objets graphiques avec les 3 premières lettres précisant le type d'objet, etc.

La syntaxe algorithmique du langagePour finir, ce qui vous a aidé à comprendre le programme est la ressemblance avec la syntaxe algorithmique connue. Il suffit de connaître les correspondances entre les structures algorithmiques et le langage. Pour cela, vous trouverez à la fin de ce cours, en dernière séquence, un mémento du C++ avec entre autres les correspondances entre algorithme et C++. Pensez à régulièrement vous référer à ce mémento pour la suite de ce cours.

Dès ce premier programme, regardez les explications du mémento pour mieux comprendre les structures utilisées : le fonctionnement de la structure itérative "while", de la structure alternative "if", de l'affichage "printf", de la saisie "scanf", etc.

3. Modification d'un programmePour ne pas aborder tout de suite l'écriture d'un nouveau programme, on va tester d'apporter des modifications au programme précédent.

Modifiez le code pour limiter le nombre d'essais à 10 puis testez votre programme.

Autre modification : en plus du nombre d'essais, affichez un message personnalisé en fin de programme. "bravo" si le nombre a été trouvé en moins de 5 essais, "bien" entre 5 et 7 essais, "moyen" entre 8 et 10 essais, "perdu" au-delà de 10 et dans ce cas il faudra afficher la valeur qu'il fallait trouver. Testez votre programme.

Si vous n'arrivez pas à réaliser correctement les modifications demandées, regardez la correction (testmodif) en prenant le temps de bien comprendre le code. Cependant, je vous conseille d'abord de passer un peu de temps sur la recherche. La correction n'est là qu'en cas de réel découragement, pour que vous n'arrêtiez pas la progression du cours. Mais n'oubliez pas que coder prend du temps, c'est normal.

8 3989 TE PA 03 21


4. Traduction d'un algorithmeMaintenant que vous avez découvert le mémento du C++ et les correspondances entre l'algorithme et le langage, vous allez tenter de traduire un algorithme.

Pour éviter des erreurs de manipulations, vous pouvez fermer le ou les projets précédents de l'espace de travail juste en faisant un clic droit dessus et en choisissant "close project". À tout moment, vous pourrez le rouvrir si vous désirez à nouveau travailler dessus.

Créez un nouveau projet, test2 et un fichier source test2.cpp.

Traduisez l'algorithme suivant :

programme somme valeur, total : entierdebut total — 0 afficher "entrer une valeur (0 pour arrêter) : " saisir valeur tantque valeur <> 0 total — total + valeur afficher "entrer une valeur (0 pour arrêter) : " saisir valeur fintantque afficher "la somme des valeurs est de : ", totalfin

Puisque c'est votre premier programme, il est possible que vous ayez des erreurs de compilations. Dans un premier temps, essayez de les corriger par vous-même en contrôlant que vous avez bien respecté la logique de l'algo et la syntaxe du C++ (en référence au mémento). Si vous restez vraiment bloqué trop longtemps, regardez la correction. Dans la séquence suivante, vous allez apprendre à utiliser les aides d'Eclipse pour la recherche d'erreurs.

22 8 3989 TE PA 03


Synthèse

Écriture et test d'un programme sous Eclipse :

• Création d'un projet : File/New/C++ Project

• Création d'un fichier source : File/New/SourceFile (donner le nom du fichier source avec l'extension cpp et en précisant le projet associé)

• Compilation du projet : sélectionner le projet puis Project/Build All (si le message "build complete for project" apparaît dans la console, la compilation s'est bien passée)

• Exécution du projet : aller sur le disque dans le dossier build du dossier du projet, et exécuter le fichier possédant l'extension exe.

Règles d'écriture d'un programme (quel que soit le langage) :

• Commentaires : pour expliquer le code

• Indentations : pour repérer les imbrications de structures

• Noms des variables : explicites

• Structures : respect des règles algorithmiques

8 3989 TE PA 03 23

Séquence 3Correction d’erreurs

Séquence 3

Correction d'erreursCette séquence ne va rien apporter de plus au niveau de la connaissance du langage, mais reste fondamentale dans le domaine du développement d'applications. Vous devez apprendre à utiliser les outils mis à votre disposition pour rechercher les erreurs d'un programme. Cette compétence est d'ailleurs systématiquement testée lors de l'épreuve pratique à l'examen.

u Capacités attendues en fin de séquenceSavoir utiliser les outils d'un IDE pour la recherche d'erreurs : débogage, exécution pas à pas, points d'arrêts, trace…

u Contenu1. Types d'erreurs ............................................................................................................................. 24

2. Erreurs de compilation ..............................................................................................................24

3. Erreurs d'exécution ................................................................................................................... 26

Synthèse ................................................................................................28

24 8 3989 TE PA 03


1. Types d'erreursIl existe 3 types d'erreurs.

Les erreurs de compilationCes erreurs sont détectées lors de la compilation (par exemple un mot réservé mal écrit, un point virgule manquant, mais aussi des erreurs plus sémantiques comme une variable non déclarée). Ces erreurs empêchent la création du fichier objet (code du programme traduit en langage machine).

Le compilateur donne la liste des erreurs de compilations. L'IDE les repère et va les signaler directement dans le code. Très souvent, il donne même des solutions de corrections.

Les erreurs de linkOn les assimile souvent aux erreurs de compilation pourtant il y a une petite nuance. Ces erreurs se produisent une fois le fichier objet créé, au moment de l'étape de link qui s'occupe de lier le fichier objet aux bibliothèques externes (et non les includes que vous avez vu pour le moment et qui permettent d'intégrer directement le code dans le programme). À votre niveau, vous n'aurez pas à utiliser de bibliothèques externes donc vous n'aurez pas d'erreur de link. Ces erreurs bloquent la création du fichier exécutable (le fichier avec l'extension exe).

Le Linker donne la liste des erreurs de link. Comme ces erreurs proviennent de liens externes, généralement l'IDE n'apporte pas plus d'informations.

Les erreurs d'exécutionCette fois le fichier exe a été créé, mais le programme provoque une erreur lors de son exécution. C'est donc la logique du programme qui n'est pas correcte.

Lors d'une erreur d'exécution, l'exécution s'arrête en affichant parfois l'origine de l'erreur (division par 0…) mais pas toujours. L'IDE offre alors une batterie d'outils pour repérer ces erreurs, en permettant par exemple l'exécution ligne par ligne du programme, l'ajout de points d'arrêts pour que l'exécution stoppe à un endroit précis et continue pas à pas, l'affichage de l'évolution du contenu des variables, etc.

Il se peut aussi que le programme s'exécute jusqu'au bout sans provoquer d'erreur d'exécution, mais ne réalise pas les traitements attendus. Les outils précités sont alors aussi utilisés pour repérer ce qui ne se passe pas correctement.

2. Erreurs de compilationEn cas d'erreurs de compilations, le compilateur donne, dans l'onglet de la console, la liste des erreurs. Le premier onglet ("Problems") détaille plus clairement la liste des erreurs. Mais l'aspect le plus visuel apparaît directement dans le code, où chaque erreur est soulignée, repérable par une croix rouge dans la marge de gauche et un petit tiret rouge dans la marge de droite.

Faisons tout de suite un essai pour mieux comprendre. Fermez les projets en cours et créez le projet "erreur". Dans ce projet, créez le fichier source "erreur.cpp". Tapez le code suivant, exactement comme il est présenté, sans chercher à corriger par vous-même les erreurs. Le programme ne comporte aucune erreur de logique, mais juste des erreurs de syntaxe.

8 3989 TE PA 03 2�


/* recherche d'erreurs * auteur : Ed * date : 28/06/2009 */

//--- bibliothèques nécessaires ---#include <stdio.h> // pour le printf et scanf

//--- programme principal ---int main () {

int i, nb ; printf("Cherche si un nombre est premier") printf("\nNombre (0 pour finir) = ") ; scanf("%d", &nb) ; while nb != 0 { i == 2 ; while (nb%i != 0 && i < nb) { i++ ; } if (i==nb) { printf("premier") ; }else{ printf(pas premier) ; } printf("\n\nNombre (0 pour finir) = ") ; scanf("%d", &nb) ; }

return 0 ;

}

Si vous avez installé la version Ganymede (donc pas le pack) vous remarquez que déjà, avant même de lancer la compilation, des points d'interrogation apparaissent dans la marge de gauche, signalant des erreurs. Le problème est que certaines erreurs en cachent d'autres, du coup vous croyez qu'il n'y en a que 2 alors qu'il y en a bien plus.

Ce problème classique pousse certains débutants à réagir de façon erronée. En effet, sur le moment ils pensent "je n'ai que 2 erreurs", puis, suite à la correction d'une erreur qui en cachait d'autres, ils pensent alors "mince, en faisant cette modification j'ai rajouté 5 erreurs". Ce qui n'est pas vrai : elles étaient bien présentes au départ mais ne se voyaient pas.

Eclipse Ganymede souligne aussi en jaune tout ce qui contient une erreur ou tout ce qui n'a pas pu être analysé suite à une première erreur.

Vous avez aussi peut-être remarqué, depuis le début que certains mots dans les commentaires ou les messages entre guillemets sont aussi soulignés : l'IDE analyse aussi ces parties là, parfois au niveau orthographique ! Bien sûr vous n'en tenez pas compte (surtout que l'analyse se fait à partir d'un dictionnaire anglais…).

Pour ceux qui ont installé le pack, donc Eclipse Europa, ces soulignements n'apparaissent pas tout de suite, mais ne soyez pas frustré, le compilateur va aussi jouer son rôle.

Bon, voyons donc maintenant comment le compilateur va réagir. Sélectionnez le projet et lancez la compilation. Cette fois, dans la marge de gauche, des croix dans des ronds

26 8 3989 TE PA 03


rouges se sont ajoutées, signalant les erreurs de compilation, et des petits traits rouges sont aussi dans la barre de droite, afin de se positionner directement sur la ligne d'erreur. Cliquez sur le premier trait rouge afin de vous positionner sur la ligne concernée (qui est aussi soulignée en rouge). Normalement vous êtes sur cette ligne :

printf("\nNombre (0 pour finir) = ") ;

Sans cliquer, mettez la souris soit sur la croix rouge, soit directement sur la ligne de code et observez le message qui apparaît (expected ; before "printf"). Traduisons : point virgule attendu avant printf. Effectivement, sur le ligne qui se trouve juste au dessus de celle-ci, il manque le point virgule final. Ajoutez-le. La croix n'a pourtant pas disparu. C'est normal car aucune compilation n'a été redemandée. Avant de relancer le compilateur, on va s'occuper des autres erreurs.

Avec la même logique et en vous aidant un peu du mémento, essayez de corriger l'erreur qui se trouve à cette ligne :

while nb != 0 {

Une fois cette erreur corrigée, vous remarquez qu'un triangle jaune avec un point d'exclamation se trouve dans la marge de droite, juste à côté de cette ligne de code :

i == 2 ;

Le message dit : statement has no effect.

Effectivement, ce n'est pas une erreur syntaxique, mais il y a tout de même un problème. On appelle ces erreurs, des "warnings". Elles ne sont pas bloquantes lors de la compilation, mais prédisent d'éventuelles erreurs de logique du programme, lors de l'exécution.

Effectivement, le signe == en C++ signifie "égalité" au niveau comparaison. Hors ici, ce n'est pas une comparaison que l'on veut faire mais une affectation. En C++, l'affectation se fait par un simple =. Corrigez l'erreur.

Essayez de corriger les erreurs restantes et relancez une compilation, jusqu'à qu'il n'y ait plus d'erreurs. Contrôlez lors de l'exécution (toujours en lançant directement le fichier exe à l'extérieur d'Eclipse) que vous n'avez pas ajouté des erreurs de logique : vérifiez que le programme affiche le message correspondant au nombre saisi.

3. Erreurs d'exécutionTrès souvent, on pense que lorsqu'un programme passe l'étape de la compilation, c'est gagné. C'est loin d'être le cas. Généralement c'est là que les vrais problèmes commencent. En effet, avec un peu d'expérience, les erreurs de compilation sont faciles à corriger. Les erreurs d'exécution peuvent être nettement plus complexes à trouver.

Avant la création des IDE, le programmeur utilisait classiquement ce que l'on appelle des affichages "tests" ou "drapeaux". En insérant dans le code, plusieurs affichages à des endroits stratégiques, cela permet de savoir l'évolution du code, par où passe l'exécution, et même l'évolution de certaines variables, cette technique est encore très largement utilisée. Cependant, les outils apportés par les IDE permettent de nouvelles techniques de recherche d'erreurs, généralement plus rapides.

Sans faire une recherche d'erreurs, on va cependant observer comment réagit le débuggeur face à un programme. Restez sur le même projet que vous avez normalement corrigé au niveau erreurs syntaxiques. Cliquez sur le petit cafard qui se trouve à gauche de la flèche blanche dans le rond vert (ou passez par les menus : Run/Debug As/Local C++Application).

8 3989 TE PA 03 2�


Une fenêtre s'ouvre proposant l'utilisation de la perspective : cette option est très pratique car elle offre un ensemble d'outils pour le débogage. Cliquez sur Yes. L'aspect de l'IDE a changé et plusieurs zones se sont ouvertes.

Vous allez ainsi pouvoir exécuter le programme pas à pas et voir l'évolution du contenu des variables.

Faisons un test. Remarquez dans la partie des variables (en haut à droite) les variables i et nb qui sont utilisées dans le programme. Vous constatez par la même occasion qu'elles contiennent des valeurs aléatoires. Effectivement, contrairement à certains langages qui initialisent par défaut les variables à 0, le C++ n'en fait rien, d'où l'importance d'initialiser les variables lorsqu'elles doivent servir pour des cumuls.

Cliquez sur la première flèche jaune qui permet d'avancer pas à pas dans le code (Step into). Dans la zone du code, remarquez que la ligne verte s'est positionnée sur le printf. Malgré les déclarations des variables, leur contenu n'a pas changé, c'est normal.

Avancez 2 fois en pas à pas. Vous êtes sur le scanf. Les affichages ne se voient pas dans la console, c'est normal (les affichages ne se voient qu'en fin d'exécution, mais cela ne va pas nous empêcher de tester le programme).

Avancez à nouveau une fois : cette fois la ligne verte a disparu : en effet, le scanf est en cours d'exécution et attend une saisie. Dans la partie Console, saisissez le nombre 73 puis validez. La ligne verte est réapparue sur le while, et cette fois, dans la partie variable, vous remarquez que nb a pris la valeur 73.

Faites 2 avancées pas à pas pour vous positionner sur le second while. Comme vous avez exécuté la ligne "i = 2 ;", remarquez dans la partie des variables que la variable i a pris la valeur 2.

Flèches pour avancer pas à pas dans le code

Évolution des variables

Arrêt de l'exécution

Évolution pas à pas dans le code

Zone de saisie

2� 8 3989 TE PA 03


Il arrive parfois que dans une exécution pas à pas, on désire sauter une partie de code un peu trop longue au niveau exécution. Ce serait le cas ici pour la recherche des diviseurs de 73. Pour sauter une partie de code, on utilise les points d'arrêts. Dans la partie code, marge de gauche, double cliquez dans la partie grise à la hauteur de la ligne du if. Vous remarquez le petit rond qui s'est mis en place : c'est un point d'arrêt. Pour sauter jusqu'au point d'arrêt, cliquez sur la flèche verte qui se trouve un peu plus à gauche par rapport à la flèche d'avancée pas à pas (cette nouvelle flèche porte le nom "Resume"). La ligne verte s'est bien positionnée sur le if, et donc a exécuté la boucle sans y passer de façon pas à pas. Remarquez le contenu des variables : i contient maintenant 73 car effectivement aucun nombre jusqu'à 73 n'est arrivé à diviser 73 (puisque ce nombre est premier).

Avancez une fois avec le pas à pas : vous remarquez que la ligne verte est positionnée sur l'affichage "premier". Une avancée pas à pas permet donc aussi de voir par où passe le programme, en particulier pour les tests. Donc là, c'est la partie "alors" du "if" qui est exécutée (même si on ne verra pas l'affichage). Avancez encore une fois pas à pas pour constater que la partie "sinon" a été sautée, donc non exécutée.

Il est possible d'arrêter l'exécution du débuggeur à tout moment : cliquez sur le carré rouge qui se trouve juste au dessus de la zone de saisie, vers la droite. Une fois que le carré n'est plus rouge, vous pouvez sortir du mode debug en cliquant tout en haut à droite sur "C/C++" (à droite de "Debug").

Synthèse

Erreur de compilation :

• Erreur syntaxique ou sémantique repérée par le compilateur et bloquant la création du fichier objet (qui doit contenir le code exécutable). Le compilateur donne la liste des erreurs.

Erreur d'exécution :

• Erreur de logique provoquant l'arrêt du programme en cours d'exécution.

Débuggeur :

• Programme offrant une batterie d'outils pour la recherche d'erreurs (exécution pas à pas, points d'arrêts, contenu des variables…)

8 3989 TE PA 03 2�

Séquence 4Applications

Séquence 4

ApplicationsCette séquence va vous permettre de créer du début à la fin 2 applications. Vous serez tout de même guidé pas à pas dans ces créations. La première application regroupe tout le code dans le programme principal, afin de ne pas aborder directement le problème des modules. La seconde application présente comment organiser le code en différents modules pour qu'il soit optimisé. Le petit bonhomme vous signale les phases de tests de l'application.

u Capacités attendues en fin de séquenceAvoir acquis les bases nécessaires pour l'élaboration d'une application complète en C++ mode non graphique.

u Contenu1. Application unique : le morpion ........................................................................................ 30

2. Application modulaire : le mastermind .......................................................................... 32

30 8 3989 TE PA 03


1. Application unique : le morpionCette application va regrouper tout le code dans le programme principal (main) comme cela a été fait dans les exemples précédents.

Vous devez réaliser un petit morpion.

Le principe est le suivant (dans le cas où vous ne savez pas jouer au morpion…) :

2 joueurs se battent sur une grille de 9 cases (3 cases de côté). Chacun à son tour doit mettre un signe dans une des cases (par convention, un joueur utilise le signe "O" et l'autre le signe "X"). Celui qui gagne est celui qui sera arrivé à aligner 3 signes identiques (en ligne, colonne ou diagonale).

Voici un exemple de visuel final d'exécution :

Commencez par fermer les projets ouverts et créez un nouveau projet "morpion", contenant un fichier source du nom de "morpion.cpp".

Pour faire cette application qui commence à être d'un certain niveau de complexité, vous allez suivre les étapes suivantes (elles vont vous aider à construire pas à pas le programme) en testant chaque étape avant de passer à la suivante :

Étape 1 : affichage de la grilleLa grille va rester fixe en permanence à l'écran. Pour dessiner la grille, vous allez utiliser "-" comme caractère pour tracer les traits horizontaux et "|" (sur la touche du 6) pour les traits verticaux.

La grille doit contenir des cases qui laissent suffisamment d'espace (un caractère suffit en fait, mais 3 c'est plus joli, comme l'exemple ci dessus) pour pouvoir ensuite insérer un "O" ou une "X".

Cela suppose que, contrairement à ce qui a été fait jusqu'à maintenant, vous devez pouvoir positionner le curseur à un endroit précis avant de pouvoir afficher. Ce positionnement est possible avec gotoxy dont vous trouverez toutes les explications dans le mémento.

Faites un test pour contrôler que la grille s'affiche correctement.

8 3989 TE PA 03 31


Étape 2 : saisie et affichage des choix des joueursAvant la boucle, il faut initialiser une variable booléenne (gagne) à faux et boucler tant que cette variable est fausse.

Dans la boucle, en positionnant correctement l'affichage (au dessous de la grille) avec gotoxy, il faut afficher ce genre de messages :

C'est au tour du joueur 1 Ligne = Colonne =

Puis encore une fois en positionnant correctement le curseur, il faut saisir le numéro de ligne et de colonne, en contrôlant que la personne saisisse bien une valeur entre 1 et 3 compris.

Une fois la saisie effectuée, il faut afficher le "O" (pour le joueur 1) ou la "X" (pour le joueur 2) dans la case correspondant au choix saisi. Le positionnement se fait avec gotoxy, et un petit calcul mathématique en fonction du numéro de ligne et de colonne.

Il faut aussi prévoir une variable numjoueur qui va prendre alternativement la valeur 1 puis la valeur 2 à chaque tour de boucle. Cette variable va aussi servir à personnaliser l'affichage "C'est au tour du joueur 1" ou "C'est au tour du joueur 2".

Faites un test pour contrôler que les lignes s'affichent bien sous la grille, que la saisie se fait au bon endroit pour le numéro de ligne et de colonne. De même, contrôlez que le rond ou la croix se positionne au bon endroit dans la grille et que, lorsque le signe est bien positionné, on passe à l'autre joueur pour une nouvelle saisie. Contrôlez aussi qu'il n'est pas possible de saisir autre chose que 1, 2 ou 3.

Pour le moment, il n'y a aucun contrôle de fait (on peut mettre une croix là où il y avait déjà un rond...).

Étape 3 : enregistrement des choix et contrôle des 3 signes successifsPour pouvoir contrôler et rechercher si un des joueurs est gagnant, il faut mémoriser les choix de chaque joueur dans un tableau à 2 dimensions (3x3) d'entiers, chaque case contiendra 1 ou 2 (1 pour le joueur 1 et 2 pour le joueur 2). Il faut donc penser à remplir ce tableau après chaque choix d'un joueur et, juste après l'avoir rempli, de contrôler si 3 signes ne sont pas alignés (à vous de trouver comment faire ce contrôle !). Ce tableau va permettre aussi d'ajouter un contrôle de saisie : un joueur ne peut pas sélectionner une case déjà remplie.

O N'oubliez pas qu'en C++, les indices de tableaux démarrent à 0. Donc quand vous déclarez un tableau de 3 cases, vous devrez ensuite le parcourir de la case 0 à la case 2.

Une fois que le gagnant est trouvé, il suffit d'afficher un message du genre :

Le joueur 1 a gagné.

Attention, il y a aussi le cas ou personne ne gagne : on s'en aperçoit en comptant les essais et si on est arrivé à 9 essais. Donc il faut rajouter un test dans la grande boucle pour sortir aussi dans ce cas là.

Faites un test final pour contrôler si le jeu fonctionne correctement. Faites plu-sieurs tests : personne ne gagne, un des 2 joueurs gagne avec une ligne, une colonne ou une diagonale. Plusieurs tests sont effectivement nécessaires pour contrôler tous les cas possibles. Contrôlez aussi qu'un joueur ne peut pas mettre un signe dans une case déjà remplie.

32 8 3989 TE PA 03


En cas de grosses difficultés, la correction de cet exercice vous est fournie. Cependant, encore une fois, dites vous que plus vous aurez passé de temps à chercher, plus vous aurez appris. La correction n'est là que pour éviter le désespoir total... Elle est aussi là pour que vous puissiez comparer avec votre solution.

2. Application modulaire : le mastermindPassons à la seconde application, plus longue et surtout nettement plus orientée vers une réelle application structurée puisqu'il va falloir créer des modules. Malheureusement pour cette application, compte tenu de la gestion du positionnement du curseur, vous ne pourrez pas réaliser de tests avant la fin de l'écriture complète de l'application. Cependant, même s'il faut éviter d'écrire un programme en un bloc et de tout tester à la fin, cela reste ponctuellement un exercice intéressant. Suivez bien les instructions sans rien oublier.

Ce TP guidé va vous permettre de mettre au point étape par étape le jeu du Mastermind en C++. Ainsi, vous allez voir ici une méthode basée sur une approche descendante pour créer ce programme en l'optimisant au maximum et surtout en mettant en œuvre l'utilisation des modules.

Il existe bien sûr sur le net des tas de versions du Mastermind. Le but de ce TP n'est pas d'arriver à faire un Mastermind (il suffirait d'en récupérer un !) mais de suivre des étapes précises pour comprendre la construction d'un programme et surtout de modules adaptés, parfois simplificateurs, parfois réutilisables, avec la mise en pratique des différents types de paramètres (E, E/S) ainsi que les types prédéfinis. Suivez donc scrupuleusement les étapes pour obtenir la version qui est demandée dans ce tp. Vous n'aurez pas (ou peu) à réfléchir sur la méthode pour réaliser le programme (les étapes vous expliquent tout, en particulier comment calculer les bien et mal placés) : toute votre attention est requise sur l'aspect modulaire.

Pensez à vous référer régulièrement au mémento en particulier pour l'écriture des modules et des paramètres.

Règles du jeuPour ceux qui ne connaissent pas le jeu du mastermind, voici les règles :

Un premier joueur choisit une formule composée de 5 couleurs parmi un lot de 7 : bleu (B), rouge (R), noir (N), vert (V), jaune (J), orange (O), gris (G).

Chaque couleur sera symbolisée par une lettre.

La formule peut contenir plusieurs fois la même couleur.

Le deuxième joueur, qui bien sur ne connaît pas la formule, doit essayer de la trouver.

À chaque essai, il propose une formule de 5 couleurs, l'ordinateur doit lui dire le nombre de couleurs bien placées et le nombre de couleurs mal placées par rapport à la formule à trouver.

Le jeu se termine lorsque le joueur a trouvé. Un message personnalisé sera alors affiché (si le joueur a trouvé en 5 essais au plus, il faut afficher le message "Bravo !", s'il a trouvé en plus de 5 essais jusqu’à 10, afficher "Correct", et s'il a mis plus de 10 essais, afficher "décevant"). Dans tous les cas, il faudra afficher le nombre d'essais utilisés par le deuxième joueur pour arriver à découvrir la bonne formule.

8 3989 TE PA 03 33


Exemple (l'affichage se basera sur cette présentation) :

1er joueur : R V R B G

(puis l'écran s'efface)

2e Joueur : Bien placé Mal placé

essai 1 B R V N J 0 3

essai 2 R B N B V 2 1

essai 3 R B N V J 1 2

essai 4 R V B B N 3 0

essai 5 R V R B G 5 0

La formule a été trouvée en 5 essais : Bravo !

Le premier joueur va donc saisir la formule de départ, puis l'écran s'efface et le second joueur commence le jeu. Il faudra utiliser gotoxy pour les positionnements précis (comme dans l'application précédente) et getche pour la saisie d'un caractère sans avoir à valider. Vous trouverez le fonctionnement détaillé du getche dans le mémento.

Bibliothèques et types globauxComencez par intégrer la bibliothèque myconio.h (suivez les explications d'intégration de cette bibliothèque dans le mémento).

Déclarez en global le type suivant :

typFormule : vecteur de caractères de 5 cases

Attention, la déclaration d'un type ne se fait pas comme pour une variable. Référez-vous au mémento pour connaître la syntaxe. Ce type va permettre de déclarer les 3 vecteurs nécessaires au jeu.

Programme principalÉcrivez la structure minimum du programme principal : l'en-tête du main mais aussi, en fin de main, le getch() qui permet d'éviter la fermeture de la fenêtre et le return 0.

Au début du programme principal, commencez par les déclarations (pensez à mettre un commentaire à côté de chaque variable) :

• 3 vecteurs varOriginal, varCopie, varEssai (ces vecteurs vont contenir respectivement la formule originale à chercher, la copie de cette formule, et les essais du 2e joueur) de type typFormule (le type que vous avez déclaré en global) ;

• 2 variables BP et MP pour compter les biens et mal placés ;

• 1 variable nbEssai pour compter le nombre d'essais ;

• un indice i de parcours de vecteurs ;

• des variables de positions pour les affichages : x et y (on pourrait en fait s'en passer).

L'étape suivante représente la saisie de la formule originale. Le principe de la saisie de la formule va être le même pour la formule originale que pour la formule d'essai. Donc il faut optimiser. Alors imaginons que vous ayez à votre disposition la fonction algorithmique suivante :

fonction saisieCouleur (x, y : entier) : caractère

Cette fonction reçoit en paramètre x et y qui représentent la position à l'écran de saisie du caractère et retourne le caractère saisi (qui fait partie des caractères autorisés).

34 8 3989 TE PA 03


Vous aurez à écrire cette fonction plus tard mais pour le moment considérez qu'elle est écrite.

Donc, pour la saisie de la formule d'origine, commencez par mettre un commentaire puis faites une boucle pour remplir le vecteur varOriginal en utilisant la fonction saisiCouleur. En ce qui concerne les coordonnées x et y, envoyez vos 2 variables en paramètre mais pour le moment ne vous inquiétez pas de leur contenu. La gestion des positions d'affichage se fera plus tard.

Avant de passer à la boucle sur les essais, initialisez nbEssai à 0 car il va compter le nombre d'essais du joueur.

Passons maintenant à la boucle générale sur les essais : vous allez répéter jusqu'à ce que la formule soit trouvée (donc jusqu'à ce qu'il y ait 5 bien placés). Avant d'écrire la boucle, mettez un commentaire pour expliquer son rôle, puis commencez la boucle.

Dès le début de la boucle, pensez à incrémenter la variable nbEssai.

Dans cette grande boucle des essais, faites une boucle de saisie sur la formule d'essai (pour remplir le vecteur varEssai), avec le même principe que la boucle de saisie de la formule originale. Cependant profitez de cette boucle pour copier le contenu du vecteur varOriginal dans varCopie car c'est à chaque fois avec varCopie que l'on va travailler. Pensez à faire précéder votre boucle d'un commentaire expliquant son rôle.

Il faut passer au calcul des biens placés. Commencez par un commentaire pour annoncer ce calcul. Vous allez à nouveau utiliser une fonction que vous écrirez plus tard.

fonction calculBP (vec1, vec2 : typFormule) : entier

Utilisez cette fonction pour remplir la variable BP. Cette fonction, à partir des 2 vecteurs passés en paramètres, retourne le nombre de bien placés.

Après les biens placés, il faut calculer les mal placés. Commencez par un commentaire pour annoncer ce calcul. Même principe que pour le calcul des biens placés, vous allez utiliser une fonction que vous écrirez plus tard.

fonction calculMP (vec1, vec2 : typFormule) : entier

Utilisez cette fonction pour remplir la variable MP. Cette fonction, à partir des 2 vecteurs passés en paramètres, retourne le nombre de mal placés.

Le calcul étant fait, il ne reste plus qu'à afficher les biens placés et mal placés. Le but est d'afficher au bon endroit. Utilisez une procédure que vous allez écrire plus tard :

procedure afficheValeur (x, y : entier ; val : entier)

Cette procédure affiche la valeur val à la position (x, y). Encore une fois, ne vous inquiétez pas du contenu des variables x et y que vous gèrerez plus tard.

À la sortie de la grande boucle sur les essais. Il ne vous reste plus qu'à gérer l'affichage du message final : le nombre d'essais et un message personnalisé. Si la personne a trouvé en moins de 6 essais, "bravo", en moins de 11, "correct", et à partir de 11, "décevant". Ne vous inquiétez toujours pas de la position d'affichage. Précédez ce bloc d'affichage d'un commentaire explicite.

Observez le code de votre programme principal : sautez une ligne entre chaque bloc de code et chaque bloc doit être précédé d'une ligne de commentaire, si vous avez bien suivi les instructions. Inutile de mettre un commentaire par ligne : un commentaire par bloc suffit largement et c'est nettement plus lisible.

Le programme principal est terminé, excepté la gestion des positions x et y que vous allez gérer plus tard. Passons maintenant à l'écriture des modules.

8 3989 TE PA 03 3�


Écriture des modules du programmeÉcrivez tous les modules avant le programme principal (après la déclaration du type et avant le main). Faites attention à l'ordre des modules. Gardez l'ordre suivant car si certains modules en utilisent d'autres, il faut toujours que les modules soient déclarés avant leur utilisation. Avant de commencer l'écriture d'un module, sautez une ligne et mettez un commentaire pour expliquer le rôle du module.

A – procédure afficheValeur (x, y : entier ; val : entier)Elle reçoit en paramètre x, y (les coordonnées de la position à l'écran) et val, la valeur entière à afficher, et affiche la valeur à la position demandée.

B – fonction saisieCouleur (x, y : entier) : caracElle reçoit en paramètre les coordonnées x et y et saisit un caractère à cette position. Il faut utiliser getche() pour la saisie sans validation. La fonction retourne le caractère correct saisi.

Il est nécessaire de boucler sur la saisie jusqu'à ce que le caractère fasse partie des couleurs autorisées. Mais comment faire ce test ? Vous allez créer une autre fonction : fonction caracValide (c : carac) : booleen. Cette fonction reçoit en paramètre un caractère et contrôle si ce caractère fait partie des couleurs autorisées. Pour cela, vous allez déclarer et initialiser un tableau de 7 cases contenant les couleurs autorisées et vous rechercherez dans ce tableau la présence de la couleur entrée en paramètre. La fonction retourne vrai s'il en fait parti, faux sinon. Pensez à écrire cette fonction au-dessus.

C – fonction calculBP (E/S : vec1, vec2 : typFormule) : entierElle reçoit en paramètre les 2 vecteurs à tester, compte le nombre de bien placés et retourne ce nombre. Pour cela, une simple boucle suffit en comparant les informations qui sont aux mêmes indices. Attention, pour éviter de reprendre en compte les cases déjà bien placées, dès que vous trouvez 2 biens placés, il faut les remplacer par d'autres caractères. Par exemple remplacer par "X" dans le premier vecteur et par "Y" dans le second. Cette astuce permet d'éviter de recompter comme mal placés, par la suite, les couleurs biens placées. Cela signifie donc que les paramètres sont en E/S puisque vous faites des modifications. La fonction retourne le nombre de biens placés.

D – fonction calculMP (E/S : vec1, vec2 : typeFormule) : entierElle reçoit en paramètre 2 vecteurs à tester et, par une double boucle imbriquée, va comparer chaque caractère du premier vecteur avec tous ceux du second. S'il y a égalité, un compteur local va être incrémenté et, avec le même principe que pour les biens placés, les caractères seront remplacés par "X" et "Y". La fonction retourne le compteur de mal placés.

Gestion de l'affichageLe programme est terminé excepté quelques détails d'affichage. Il reste à gérer l'évolution des variables x et y pour se positionner correctement à l'écran.

Pour cela, réfléchissez et exploitez les variables que vous avez déjà, par exemple nbessai doit vous permettre de gérer le x (le numéro de ligne). Quant au numéro de colonne (y), il peut facilement être calculé.

Pensez aussi que certaines informations doivent être affichées, comme "1er joueur" et "2e joueur", l'effacement de l'écran entre la saisie du premier joueur et les essais du second, les titres (bien placé, mal placé, essai 1…), le message final.

36 8 3989 TE PA 03


Faites les modifications nécessaires (gestion des x et y, affichages complémentaires) pour obtenir le résultat présenté au tout début. Logiquement, si vous avez bien géré les positions par calculs, vous devriez pouvoir enlever les déclarations de x et y qui sont dans le programme principal. Pour les positions, vous allez certainement souffrir un peu : n'hésitez pas à faire plusieurs tests. Cela va aussi vous donner l'occasion de corriger certainement d'autres erreurs…

Ce n'est donc qu'au final que vous pouvez enfin tester. Soyez patient, vous allez certainement rencontrer dans un premier temps plusieurs erreurs de compilations, puis des erreurs d'exécutions. Attention, lorsqu'il n'y a plus d'erreurs de compilations, un fichier exe est créé. Si par la suite vous modifiez le code et sans le vouloir vous ajoutez une nouvelle erreur de compilation, vous aurez l'impression que rien n'a changé car ce sera le même fichier exe qui sera exécuté. Il est donc conseillé de supprimer directement du disque, entre chaque compilation, le fichier exe.

Voilà, vous êtes arrivé au bout… Si ce n'est pas le cas, la correction est à votre disposition. Mais encore une fois, pensez à vous y référer qu'en tout dernier ressort.

8 3989 TE PA 03 3�

Séquence 5Mémento du C++

Séquence 5

Mémento du C++Cette séquence regroupe les bases de connaissances à connaître pour écrire un programme non graphique en C++. La présentation est volontairement simplifiée : le langage étant très vaste, vous vous doutez bien que vous n'allez aborder qu'une infime partie. Cette séquence, contrairement aux autres, ne contient pas d'étapes de créations ou de tests mais représente un résumé qui doit vous servir de référence pour réaliser les travaux contenus dans les autres séquences.

u Capacités attendues en fin de séquenceIl n'y a pas de capacités attendues : cette séquence sert juste de référence aux autres séquences de ce cours.

u Contenu1. Structure d'un programme.................................................................................................. 38

2. Correspondances algo / C++ ............................................................................................. 38

3. Déclarations .............................................................................................................................. 40

4. Syntaxe et règles fondamentales ................................................................................... 41

5. Includes ........................................................................................................................................ 42

6. Modules ...................................................................................................................................... 44

3� 8 3989 TE PA 03


1. Structure d'un programmeUne application simple en C++ comporte les parties suivantes :

int main () { ... return 0 ;}

Le main représente le programme principal. Il est considéré comme "la fonction principale" et doit être de type int, donc retourner un entier. Sauf cas spéciaux, par défaut on met en fin de main un "return 0".

Avec ce tout premier exemple, vous remarquez que :

• le type se met en premier (ce sera vrai pour toutes les déclarations) ;

• les accolades entourent un groupe d'instructions (ce sera vrai pour toutes les structures algorithmiques) ;

• une instruction se termine par un point virgule (ce sera vrai pour toutes les instructions).

Que peut-on trouver avant le main ?• les includes : intégration de bibliothèques de fonctions déjà écrites (les includes

sont présentés en détail par la suite) ;

• les déclarations globales : déclarations de constantes, de types et de variables globales ;

• Les modules : chaque module doit toujours être écrit avant d'être appelé (la déclaration et utilisation des module est présentée plus loin).

Que peut-on trouver dans le main ?• les déclarations locales au main ;

• Les instructions du programme.

Que peut-on trouver après le main ?Rien ! La fin du main marque la fin du programme. Comme tout doit être écrit avant d'être sollicité, rien ne peut être écrit après le main qui est le point d'entrée du programme.

2. Correspondances algo/C++Voici un tableau qui va vous présenter la correspondance entre les syntaxes algorithmiques et le langage C++.

Algo C++

// commentaire d'une ligne/* commentairede plusieurs lignes */

Les types :entier, entier long, réel, caractère, booléen

(dans le même ordre : )int ou Integer, long, float, char, boolean

nomVariable : typeVariableexemple :k : entier

typeVariable nomVariable ;exemple :int k ;

8 3989 TE PA 03 3�


nomTableau[1..N] : typeTableauexemple :tab[1..10] : entier

typeTableau nomTableau[N] ;exemple :int tab[10] ;Remarque : attention en C++ les indices de tableaux commencent à 0. Donc, ici le tableau tab déclaré avec 10 cases, possède des cases numérotées de 0 à 9.

nomTableau[1..N, 1..M] : typeTableauexemple :tab[1..10, 1..3] : entier

typeTableau nomTableau[N][M] ;exemple :int tab[10][3] ;

nomVariable fl valeur nomVariable = valeur ;

signes de comparaison et logique :=, <>, <, >, <=, >=, non, et, ou

(dans le même ordre : )==, !=, <, >, <=, >=, !, &&, ||Remarque : attention de bien mettre == lors d'une comparaison (dans un if, par exemple) car le = tout seul ne va pas provoquer d'erreur, mais ne fera pas la même chose.

opérations :+, -, *, /, div, mod

(dans le même ordre : )+, -, *, /, /, %Remarque : il n'y a pas de division entière (div) mais une division simple avec une affectation dans une variable de type entier donne le même résultat.

Quelques raccourcis d'écriture (non obligatoires mais bien pratiques) :A fl A + 1A fl A + BA fl A – 1A fl A – BA fl A * BA fl A / B

A++ A += B A-- A -= B A *= B A /= B

si condition alors actionfinsi

if (condition) { action ;}Remarque : attention de ne pas oublier les parenthèses autour de la condition (obligatoire pour toutes les conditions, que ce soit dans les if, while etc…)

si condition alors action1sinon action2finsi

if (condition) { action1 ;}else{ action2 ;}

40 8 3989 TE PA 03


cas de (variable) valeur1 : traitement1 ... valeurN : traitementNfincas

switch (variable) { case valeur1 : traitement1 ; break ; ... case valeurN : traitementN ; break ;}Remarque : ne pas oublier le break en fin de chaque cas (sinon les cas suivants sont traités)

tantque condition actionfintantque

while (condition) { action ;}

repeter actionjusqu'à condition

do { action ;}while(condition) ;

pour k de deb à fin actionfinpour

for (k = deb ; k <= fin ; k++) { action ;}

procedure nomProc (param1 : type1, …, paramN : typeN) déclarationsdebut traitementsfin

void numProc (type1 param1, …, typeN paramN) { déclarations ; traitements ;}Remarque : void signale l'absence de type retourné, donc la procédure.

fonction nomFonc (…) : typeRetour déclarationsdebut traitements retourner valeurfin

typeRetour nomFonc (…) { déclarations ; traitements ; return valeur ;}

3. DéclarationsAu-delà des informations données dans le tableau précédent, voici quelques compléments.

Déclaration d'un nouveau typeIl suffit de faire précéder la déclaration du mot réservé typedef. Voici un exemple de déclaration et d'utilisation d'un type :

typedef int tab[10] ; // tab est un type de 10 cases d'entiers...tab monTableau ; // monTableau est du type tab

8 3989 TE PA 03 41


Déclaration d'une constanteUne constante se déclare de la façon suivante :

#define nomConstante valeur ;

Voici un exemple :

#define taille 3 ;

Pour une constante, il est inutile de préciser le type : le type provient de l'initialisation de la constante.

Déclarations des variables globalesLes variables globales se déclarent comme des variables classiques, mais leurs déclarations sont placées en tête de programme, juste après les includes, define et typedef.

Déclarations de variables localesLes variables déclarées dans un module sont locales à ce module. La portée d'une variable peut même être réduite à un bloc de code : une variable déclarée dans une boucle n'est visible que dans la boucle. Il est possible de déclarer et initialiser en même temps une variable. Voici un petit exemple classique :

for (int k=0 ; k<10 ; k++) { ...}

Dans cet exemple, la variable k est déclarée et initialisée au niveau de la boucle et ne sera visible que dans la boucle.

Distinction entre caractère et chaîne de caractères

O Le C++ fait la distinction entre une chaîne de caractères qui est entre guillemets ("…") comme par exemple les messages affichés, et les variables de type caractère (char) qui ne contiennent qu'un seul caractère qui est représenté entre quotes ('…').

Dans ce cours, nous n'utiliserons pas les variables de type chaînes de caractères (un peu complexes à manipuler) mais uniquement des variables de type caractère (char). Cependant les chaînes sont utilisées dans les messages affichés.

Initialisation d'un tableau en une ligneVoici, à travers un exemple, une écriture raccourcie pour initialiser un tableau :

nomTableau = {'R', 'V', 'B', 'N'} ;

Ici, nomTableau est un tableau de char, contenant 4 cases.

4. Syntaxe et règles fondamentalesLe C++ étant à l'origine un langage procédural, la traduction des algorithmes est très facile et linéaire. En revanche, le langage impose un certain nombre de règles.

La casse

O La casse (distinction entre les majuscules et les minuscules) a une grande importance en C++.

42 8 3989 TE PA 03


Par exemple, else est différent de Else ou de ELSE, et seul le premier sera reconnu par le C++. Mais les éditeurs permettent généralement de visualiser les mots reconnus (écrits en gras). Cependant, l'erreur est plus difficilement visible lorsqu'il s'agit d'un nom de variable ou de module.

Les encadrements et fins d'instructionsLes blocs d'instructions doivent être encadrés par des accolades "{…}". Cela concerne le contenu du programme principal, des modules, des boucles, de la partie "alors" des conditions et de la partie "sinon" des conditions.

Chaque instruction doit se terminer par un point-virgule ";".

Les testsTous les tests (aussi bien au niveau des boucles que des conditions) doivent être entourés de parenthèses "(…)".

Les débordementsL'erreur classique consiste à parcourir un tableau à partir de la case 1 au lieu de commencer à la case 0. Du coup, il y a débordement au-delà de la dernière case. Le problème est que le C++ ne va pas provoquer d'erreur pour autant. Du coup vous pouvez vous trouver avec des exécutions exotiques sans comprendre pourquoi.

Un exemple : si vous remplissez un tableau de la case 1 à la case 10 (au lieu d'aller de 0 à 9) vous allez remplir une case mémoire qui se trouve après la dernière case du tableau. Cette case contient peut-être quelque chose d'important, comme par exemple l'adresse d'appel d'un module. Du coup, votre programme peut très bien se tromper d'adresse quand il appelle un module, et provoquer une exécution totalement aléatoire.

OO Cette erreur est difficilement détectable : contrôlez toujours l'utilisation des indices des tableaux.

Les indentationsAucune règle de présentation n'est obligatoire dans un langage de programmation, puisque le compilateur transcrit tout le code de façon linéaire, en enlevant les espaces en trop et les validations. Cependant, il est fortement recommandé de suivre des règles de présentation strictes afin de rendre le programme lisible. L'IDE vous aide dans ce respect des règles d'indentation.

Les commentairesIl est aussi fortement recommandé d'intégrer des commentaires dans le programme pour le rendre encore plus compréhensible.

5. IncludesUn include se met en début de programme. Il permet d'intégrer un fichier include (contenant l'extension .h) au programme. Ces fichiers s'appellent aussi des bibliothèques. Ils contiennent tout simplement des déclarations (constantes, modules…) écrites en C++ qui pourront être utilisées dans n'importe quel programme intégrant cet include.

Pour intégrer un tel fichier dans votre programme, il suffit de contrôler que le fichier existe bien (ou éventuellement de l'ajouter dans le dossier include du compilateur, ici mingw, quand c'est un fichier récupéré) et d'insérer en tout début de programme, la ligne de code suivante :

#include <nomfichier.h>

8 3989 TE PA 03 43


Il existe beaucoup de fichiers include en C++, suivant les besoins. Voici ceux que l'on va utiliser (ces includes possèdent de nombreux modules, seuls ceux nécessaires dans ce cours sont présentés).

stdio.hCe fichier contient entre autre les modules qui permettent de gérer les affichages et saisies, avec printf et scanf.

printf : permet d'afficher un message à l'écran. Voici la syntaxe à travers des exemples d'utilisation :

printf("un message") ; // permet d'afficher "un message"printf("valeur %d =", val) ; //remplace %d par le contenu de val

%d : intégration d'une variable décimale (entière)

%c : intégration d'une variable caractère

O Les caractères accentués ne sont pas compris par printf, il faut les remplacer par les codes correspondants :

ü : \x81

é : \x82

â : \x83

ä : \x84

à : \x85

ç : \x87

ê : \x88

ë : \x89

è : \x8A

ï : \x8B

î : \x8C

(printf possède de nombreuses autres options que nous n'utiliserons pas).

scanf : permet de saisir une valeur et de l'affecter à une variable. Voici la syntaxe à travers un exemple d'utilisation :

scanf("%d", &val) ; // permet de saisir un entier (%d) et de l'affecter dans val

Remarquez bien le signe & devant le nom de la variable. Ce signe est obligatoire. Il permet d'accéder à l'adresse de la variable : il est obligatoire dans le cadre d'une saisie. Nous ne détaillerons pas plus cet aspect : vous comprendrez mieux cette notion à travers le cours sur les pointeurs que vous verrez en 2e année.

conio.hCe fichier contient les modules getch et getche qui permettent une saisie sans validation.

getch() : permet de saisir un caractère sans validation, sans affichage à l'écran, et retourne le caractère saisi.

c = getch() ; // le caractère saisi est transféré dans c

La fonction getch() est souvent utilisée en fin de main, juste avant le return 0, afin d'attendre la saisie d'une touche avant de fermer la fenêtre d'exécution. Cela permet d'avoir le temps de lire les informations affichées avant que la fenêtre se ferme.

44 8 3989 TE PA 03


getche() : même principe que getch() excepté que le caractère saisi s'affiche à l'écran.

stdlib.hCe fichier contient le module system qui permet entre autre d'effacer l'écran.

system("cls") : efface le contenu de la fenêtre d'exécution, en mode dos et uniquement sous le système windows.

myconio.hCette bibliothèque ne fait pas partie des bibliothèques classiques intégrées dans tous les compilateurs du C++. Elle a été écrite par une personne qui désirait accéder à des fonctions spécifiques au compilateur de Borland et bien pratiques pour le positionnement du curseur à l'écran. Son nom fait d'ailleurs référence à la bibliothèque conio.h de Borland. Cette bibliothèque va plus loin puisqu'elle intègre aussi toutes les fonctions qui viennent d'être citées dans les bibliothèques précédentes. Du coup, quand vous utiliserez cette bibliothèque, vous pourrez enlever les includes précédents. Pour utiliser myconio.h, récupérez le fichier myconio.zip qui vous a été mis en Téléchargement (http://www.campus-electronique.fr/BTS-InformatiqueGestion/ puis rubrique Téléchargement) : il contient 2 fichiers, myconio.h et myconio.cpp qui doivent être placés dans le dossier include de MinGW (normalement, MinGW\include).

gotoxy(x, y) : positionne le curseur aux coordonnées passées en paramètre (colonne x, ligne y, sachant que le coin au gauche de la fenêtre a pour coordonnées 0, 0).

6. ModulesLes modules doivent être déclarés avant d'être utilisés. Voilà pourquoi le main est toujours en fin de fichier.

Déclaration d'un moduleIl se déclare en début de projet, avant le programme principal ou le module qui doit l'appeler et après les includes, define et typedef.

//--- Déclaration d'une procédure ---void nomProc (liste des paramètres) { traitements ;} ...//--- Déclaration d'une fonction ---type_retourné nomFonction (liste des paramètres) { traitements ; return valeur ;}

Les paramètres sont séparés par des virgules. Ils sont obligatoirement précédés de leur type.

Les paramètresPassage en Entrée (passage par valeur) : c'est le passage par défaut, donc rien de plus à faire.

Passage en E/S (passage par adresse) : il faut ajouter le signe & collé devant le nom du paramètre.

8 3989 TE PA 03 4�


Exemples de déclarations//--- Exemple de déclaration de procédure ---void afficheCarac (char c) { printf("%c", c) ;}

//--- Exemple de déclaration de fonction ---int factoriel (int nb) { int tot = 1 ; for (int i=2 ; i<=nb ; i++) { tot *= i ; } return tot ;}

Utilisation d'un moduleL'utilisation d'un module se fait à l'endroit souhaité, en appelant simplement son nom, suivi éventuellement des valeurs de ses paramètres.

//--- Appel d'une procédure ---nomProc(liste des valeurs) ;...//--- Exemple d'appel d'une fonction ---variable = nomFonction(liste des valeurs) ;

Les valeurs transférées dans les parenthèses doivent être séparées par des virgules.

Élisabeth diaz algorithmique et langagesthe.file.free.fr/1er-année bts ig/algorithmique_et...8...

Documents