Algorithmique et langages Programmation en C++

Transcription

BTS Informatique de gestion
1re année
Élisabeth Diaz
Algorithmique et langages
Cours 3
Programmation en C++
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).
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
Conseils généraux
1. Importance du cours pour l'examen
Ce 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 cours
Ce 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 1
Installation et configuration
Cette 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équence
Avoir compris comment configurer les différents outils nécessaires pour
développer dans un langage.
u Contenu
1. Que doit-on installer ? . ............................................................................................................... 8
2. Installation détaillée . ................................................................................................................... 9
3. Installation rapide du pack .................................................................................................... 12
Séquence 1
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 source
Le 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écutable
Une 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.
Séquence 1
8 3989 TE PA 03
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 code
Une 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.
2. Installation détaillée
Pour 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.
MinGW
Mê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.
Séquence 1
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.
Séquence 1
10 8 3989 TE PA 03
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é).
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 GDB
Il 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-mingw3.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
e réalisez les étapes de cette partie que lorsque vous aurez fini ce cours. En effet,
O Nvous
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).
Séquence 1
8 3989 TE PA 03
11
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.
Séquence 1
12 8 3989 TE PA 03
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 pack
Comme 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.
Installation du pack
Le pack vous est fourni (eclipsecpppack-0.1.zip) (http://www.campus-electronique.fr/BTSInformatiqueGestion/ 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é…
Test
Faisons 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.
Séquence 1
8 3989 TE PA 03
13
Séquence 2
Premiers programmes
Cette 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.
Savoir écrire et tester de petites applications. Connaître les bases de la
syntaxe du langage C++ : saisie, affichage, affectation, calcul, condition,
itération.
u Contenu
1. Présentation d'Eclipse . ..............................................................................................................16
2. Test d'un programme .................................................................................................................17
Séquence 2
Premiers programmes
3. Modification d'un programme . ............................................................................................20
8 3989 TE PA 03
4. Traduction d'un algorithme ....................................................................................................21
Synthèse
. .............................................................................................. 22
15
1. Présentation d'Eclipse
Eclipse 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 :
menus
Les fichiers
du projet
Séquence 2
Premiers programmes
16 8 3989 TE PA 03
Exécution dans l'IDE
Zone de travail : code
source (colorisé)
Les composants
du fichier
Onglet pour lister
les erreurs
Onglet pour afficher la
console de visualisation
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.
2. Test d'un programme
Vous 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
*/
Les étoiles du commentaire
s'insèrent automatiquement à
partir de la seconde ligne.
//--- 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 () {
La saisie de l'accolade ouvrante crée
l'accolade fermante (idem pour les
guillemets)
// 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 !") ;
Les indentations
}else{
sont automatiques
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 ;
}
Séquence 2
Premiers programmes
8 3989 TE PA 03
17
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 :
Séquence 2
Premiers programmes
18 8 3989 TE PA 03
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 commentaires
Plusieurs 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
*/
• 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>
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.
tombez pas dans l'erreur classique qui consiste à dire "je code d'abord et je
O Ne
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 indentations
Le 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.
Séquence 2
Premiers programmes
8 3989 TE PA 03
19
Les noms des variables
Les 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 langage
Pour 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.
Séquence 2
Premiers programmes
20 8 3989 TE PA 03
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 programme
Pour 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.
4. Traduction d'un algorithme
Maintenant 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 : entier
debut
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 : ", total
fin
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.
Séquence 2
Premiers programmes
8 3989 TE PA 03
21
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) :
Séquence 2
Premiers programmes
22 8 3989 TE PA 03
• Commentaires : pour expliquer le code
• Indentations : pour repérer les imbrications de structures
• Noms des variables : explicites
• Structures : respect des règles algorithmiques
Séquence 3
Correction d'erreurs
Cette 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.
Savoir utiliser les outils d'un IDE pour la recherche d'erreurs : débogage,
exécution pas à pas, points d'arrêts, trace…
u Contenu
1. Types d'erreurs ............................................................................................................................ 24
2. Erreurs de compilation ..............................................................................................................24
3. Erreurs d'exécution ................................................................................................................... 26
Synthèse
. .............................................................................................. 28
Séquence 3
Correction d’erreurs
8 3989 TE PA 03
23
1. Types d'erreurs
Il existe 3 types d'erreurs.
Les erreurs de compilation
Ces 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 link
On 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écution
Cette 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.
Séquence 3
24 8 3989 TE PA 03
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 compilation
En 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.
/* recherche d'erreurs
* auteur : Ed
* date : 28/06/2009
*/
//--- bibliothèques nécessaires --#include <stdio.h>
//--- 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
Séquence 3
8 3989 TE PA 03
25
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 celleci, 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.
Séquence 3
26 8 3989 TE PA 03
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écution
Trè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).
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.
Évolution des variables
Flèches pour avancer pas
à pas dans le code
Évolution pas à pas
dans le code
Zone de saisie
Arrêt de l'exécution
Séquence 3
8 3989 TE PA 03
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.
27
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
Séquence 3
28 8 3989 TE PA 03
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…)
Séquence 4
Applications
Cette 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.
Avoir acquis les bases nécessaires pour l'élaboration d'une application
complète en C++ mode non graphique.
u Contenu
1. Application unique : le morpion ........................................................................................ 30
2. Application modulaire : le mastermind .......................................................................... 32
Séquence 4
Applications
8 3989 TE PA 03
29
1. Application unique : le morpion
Cette 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 :
Séquence 4
Applications
30 8 3989 TE PA 03
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 grille
La 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.
Étape 2 : saisie et affichage des choix des joueurs
Avant 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 successifs
Pour 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.
pas qu'en C++, les indices de tableaux démarrent à 0. Donc quand
O N'oubliez
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.
Séquence 4
Applications
8 3989 TE PA 03
31
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 mastermind
Passons à 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.
Séquence 4
Applications
32 8 3989 TE PA 03
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 jeu
Pour 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.
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 1B
R
V
N
J
0
3
essai 2R
B
N
B
V
2
1
essai 3R
B
N
V
J
1
2
essai 4R
V
B
B
N
3
0
essai 5R
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 globaux
Comencez 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).
Séquence 4
Applications
8 3989 TE PA 03
33
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.
Séquence 4
Applications
34 8 3989 TE PA 03
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.
É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) : carac
Elle 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) : entier
Elle 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) : entier
Elle 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'affichage
Le 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.
Séquence 4
Applications
8 3989 TE PA 03
35
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.
Séquence 4
Applications
36 8 3989 TE PA 03
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.
Il 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 Contenu
1. 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
Séquence 5
Mémento du C++
8 3989 TE PA 03
37
1. Structure d'un programme
Une 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).
Séquence 5
Mémento du C++
38 8 3989 TE PA 03
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
/* commentaire
de 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 : typeVariable
exemple :
k : entier
typeVariable nomVariable ;
exemple :
int k ;
nomTableau[1..N] : typeTableau
exemple :
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] : typeTableau
exemple :
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
==, !=, <, >, <=, >=, !, &&, ||
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
+, -, *, /, /, %
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) :
AflA+1
AflA+B
AflA–1
AflA–B
AflA*B
AflA/B
A++
A += B
A-A -= B
A *= B
A /= B
si condition alors
action
finsi
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
action1
sinon
action2
finsi
if (condition) {
action1 ;
}else{
action2 ;
}
Séquence 5
Mémento du C++
8 3989 TE PA 03
39
Séquence 5
Mémento du C++
40 8 3989 TE PA 03
cas de (variable)
valeur1 : traitement1
...
valeurN : traitementN
fincas
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
action
fintantque
while (condition) {
action ;
}
repeter
action
jusqu'à condition
do {
action ;
}while(condition) ;
pour k de deb à fin
action
finpour
for (k = deb ; k <= fin ; k++) {
action ;
}
procedure nomProc (param1 : type1, …,
paramN : typeN)
déclarations
debut
traitements
fin
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éclarations
debut
traitements
retourner valeur
fin
typeRetour nomFonc (…) {
déclarations ;
traitements ;
return valeur ;
}
3. Déclarations
Au-delà des informations données dans le tableau précédent, voici quelques
compléments.
Déclaration d'un nouveau type
Il 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
Déclaration d'une constante
Une 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 globales
Les 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 locales
Les 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
C++ fait la distinction entre une chaîne de caractères qui est entre guillemets
O Le("…")
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 ligne
Voici, à 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 fondamentales
Le 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
(distinction entre les majuscules et les minuscules) a une grande importance
O Laen casse
C++.
Séquence 5
Mémento du C++
8 3989 TE PA 03
41
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'instructions
Les 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 tests
Tous les tests (aussi bien au niveau des boucles que des conditions) doivent être entourés
de parenthèses "(…)".
Les débordements
L'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.
Séquence 5
Mémento du C++
42 8 3989 TE PA 03
erreur est difficilement détectable : contrôlez toujours l'utilisation
OO Cdesetteindices
des tableaux.
Les indentations
Aucune 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 commentaires
Il est aussi fortement recommandé d'intégrer des commentaires dans le programme pour
le rendre encore plus compréhensible.
5. Includes
Un 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>
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.h
Ce 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
caractères accentués ne sont pas compris par printf, il faut les remplacer par les
O 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.h
Ce 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.
Séquence 5
Mémento du C++
8 3989 TE PA 03
43
getche() : même principe que getch() excepté que le caractère saisi s'affiche à l'écran.
stdlib.h
Ce 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.h
Cette 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. Modules
Séquence 5
Mémento du C++
44 8 3989 TE PA 03
Les 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 module
Il 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ètres
Passage 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.
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 module
L'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.
Séquence 5
Mémento du C++
8 3989 TE PA 03
45

Algorithmique et langages Programmation en C++

Transcription

Documents pareils

Dear Parents, Brussels, 18/03/2015 As you have no doubt

Quel est le meilleur IDE java

TRANSFORMATEURS

mode d`emploi - Médiathèque municipale de Villeneuve d`Ascq

Yummy. Contenu: 106 cartes 1 règle Le jeu contient 106 cartes

nessa hudgf

Installation LTE-SIM Simulation du réseau 4G (LTE

Pour consulter le manuel d`utilisation d`une machine John Deere