Centre Informatique pour les Lettres et les Sciences Humaines

TD 2 : Cration de variables, de types et de rfrences

1 - Prparatifs .......................................................................................................................... 2 Cration du projet ...........................................................................................................2 Configuration de l'environnement....................................................................................2 2 - Les variables de type standard et leur initialisation ............................................................. 3 Une variable non initialise .............................................................................................3 Erreurs frquentes ..........................................................................................................4 Utilisation de caractres interdits ...........................................................................4 Fragmentation du nom ...........................................................................................5 Oubli du point-virgule final ....................................................................................5 Une variable initialise ....................................................................................................5 Erreurs d'initialisation............................................................................................6 Conversion automatique.........................................................................................6 Une variable de type pointeur..........................................................................................7 3 - Cration et utilisation d'un type numr............................................................................ 7 Dfinition "sur place".......................................................................................................7 Dfinition dans un fichier .h............................................................................................8 Utilisation .......................................................................................................................8 4 - Cration et utilisation d'une classe...................................................................................... 8 Dfinition ........................................................................................................................9 Instanciation ...................................................................................................................9 5 - Cration de rfrences......................................................................................................... 9 Problmes de conformit des types ..................................................................................9 6 - Qu'avons nous appris ?..................................................................................................... 10

Document du 23/10/07

- Retrouvez la version la plus rcente sur

http://www.up.univ-mrs.fr/wcpp

VC++ 6.0

TD 2 : cration de variables

2/10

Contrairement aux autres, le programme que vous allez crer au cours de ce TD ne comporte aucune interface graphique. Notre tude du langage C++ est en effet encore trop peu avance pour que vous puissiez crire du code dont l'excution prsente un intrt quelconque pour un utilisateur. A ce stade, mieux vaut sans doute rester entre programmeurs et ne s'intresser qu'au fonctionnement interne du programme

1 - Prparatifs
Du fait qu'il est dpourvu d'interface utilisateur, le programme que vous allez crire ne ncessite pas un projet Qt, et nous allons donc nous contenter d'un projet Visual C++ simple. Cration du projet Aprs avoir lanc Visual C++ , droulez le menu File et choisissez la commande "New" .

Dans le dialogue qui s'ouvre alors (cf. ci-contre), choisissez l'onglet "Projects" . Dans la liste des types de projets proposs, slectionnez l'option "Win32 Application" . Fournissez un nom dans la zone d'dition "Project name" , et, dans la zone "Location", indiquez quel endroit vous souhaitez voir cr le dossier qui contiendra les fichiers correspondants ce projet .
A la diffrence de celui rencontr lors de la cration d'un projet Qt, le dialogue ouvert par le bouton permet ici de dsigner normalement le dossier o sera cr le dossier projet.
Le dialogue de cration de projet de Visual C++

Refermez ce dialogue en cliquant sur le bouton "OK"

. et cliquez sur le

Dans le dialogue suivant, slectionnez l'option "A simple Win32 Application" bouton "Finish" .

Une dernire fentre vous informe que le projet cr correspond un programme qui "run and exit immediately" (c'est dire "s'excute et se referme immdiatement"), ce qui veut simplement dire qu'il est dpourvu d'interface. Cliquez sur le bouton "OK" . Configuration de l'environnement Dans l'onglet "ClassView" de la fentre "Workspace", dployez le dossier "Globals" et doublecliquez sur l'unique entre qu'il contient ("WinMain(") . La scne obtenue devrait alors ressembler la suivante :

Nota bene : Utilisez, si ncessaire, les commande "Output" et "Workspace" du menu "View" pour rendre visible les fentres qui seraient manquantes. La taille des diffrentes fentres peut tre ajuste en dplaant leurs frontires l'aide de la souris.

L'interface utilisateur de Visual C++ J-L Pris - 23/10/07

VC++ 6.0

TD 2 : cration de variables

3/10

Visual C++ a prpar pour vous un fichier nomm TD02.CPP, qui contient un programme compos d'une unique fonction. Cette fonction, nomme WinMain(), sera automatiquement excute lorsque le programme sera lanc et c'est donc ici que vous allez crer quelques variables et rfrences. Toutes les instructions crant des variables ou des rfrences que vous allez crire au cours de ce TD devront figurer entre la ligne //TODO : Place code here et la ligne return 0; Cliquez avec le bouton droit sur la ligne "return 0;", et, dans le menu qui surgit alors, choisissez la commande "Insert/remove breakpoint" . Un point rouge doit apparatre dans la marge de gauche, sur la ligne return 0.

Une ligne de code dote d'un point d'arrt

Ce point rouge signale la prsence d'un point d'arrt, c'est--dire d'une ligne sur laquelle l'excution du programme fera une pause pour nous permettre d'examiner l'tat des variables.
L'utilisation de points d'arrts et l'examen des variables ne sont rendus possibles que par l'excution du programme sous la supervision d'un programme spcial, appel un debugger.

2 - Les variables de type standard et leur initialisation

Pour avoir des variables examiner, il vous faut bien entendu introduire dans le programme des lignes de code ayant pour effet d'en dfinir Une variable non initialise Insrez, dans la fonction WinMain(), la ligne suivante int maPremiereVariable; Vrifiez que votre ligne de code est parfaitement conforme au modle (pas d'accent, pas d'espaces intempestifs et un point virgule final) , puis compilez votre programme .
Rappel : la compilation peut tre obtenue en pressant la touche F7, qui correspond la commande "Buid" du menu "Build" (compilation et dition des liens).

La compilation de cette ligne de code produit un avertissement :

Le compilateur nous signale que notre variable est "unreferenced", ce qui signifie qu'elle est dfinie, mais que notre programme n'ordonne aucune action la concernant. Un programme qui dfinit une variable pour n'en rien faire ensuite contient vraisemblablement une erreur, et ce warning est une invitation la corriger. Avant de procder cette correction, nous allons toutefois procder un certain nombre d'observations et d'expriences. Dans le menu "Build", slectionnez la ligne "Start debug" et, dans le sous-menu qui s'ouvre alors, la commande "Go" (vous pouvez aussi, plus simplement, presser la touche F5) . Le point rouge symbolisant le maintenant surcharg d'une flche que le debugger a interrompu le l'excution de l'instruction return point d'arrt est jaune, qui indique programme avant 0. .

Reprez la fentre "Variables" du debugger

Si cette fentre n'est pas visible, slectionnez la commande du mme nom dans le sous-menu "Debug windows" du menu "View".

La fentre "Variables" du debugger J-L Pris - 23/10/07

VC++ 6.0

TD 2 : cration de variables

4/10

Dans son onglet "Locals", cette fentre propose un tableau contenant les noms et valeurs courantes de toutes les variables de la fonction o a eu lieu l'interruption du programme. Si les quatre premires de ces variables ne nous concernent pas (ce sont les paramtres de la fonction, objets que nous n'tudierons qu'au cours de la Leon 5), la dernire ligne indique effectivement la prsence de notre variable. Comme vous pouvez le constater, Une variable non initialise n'est pas "vide", et ne contient pas forcment la valeur 0.
Les programmeurs dbutants ont souvent l'intuition qu'une variable est une sorte de bote et que, par consquent, elle est vide tant qu'on n'a rien mis dedans. Si la mtaphore de la bote n'est pas fondamentalement mauvaise, il ne faut pas oublier qu'une variable correspond une zone mmoire, que cette dernire forcment un tat lectrique dtermin, et que tous les tats lectriques sont interprtables comme des valeurs de la variable. La notion de vide n'a tout simplement aucun sens dans le cas des variables.

Comme la "valeur" d'une variable non initialise est imprvisible, l'utiliser dans un programme est rarement une bonne ide. Il est donc prfrable de suivre le conseil implicitement donn par le compilateur et d'initialiser les variables. Mettez fin l'excution du programme en choisissant, dans le menu "Debug", la commande "Stop debugging" . Erreurs frquentes La saisie du texte source donne souvent lieu des erreurs bnignes, qui empchent nanmoins la compilation du programme. Il est donc important d'apprendre reconnatre la source du problme partir des messages de protestation mis par le compilateur. Utilisation de caractres interdits Modifiez ainsi la ligne de code dfinissant la variable int maPremireVariable; Lors de la compilation (F7) , les messages d'erreur suivants sont mis : :

Une unique faute de frappe peut causer plusieurs erreurs de compilation. Le compilateur ne cherche pas compter vos erreurs pour vous mettre une note, il cherche traduire le texte source en une squence d'instructions excutables par le processeur. Lors de son analyse du texte, la prsence du '' fautif le laisse face trois fragments de texte :
1 2 3

int maPremi reVariable; Ainsi, si la prsence du caractre inconnu '' (en anglais : unknown character) est bien la premire erreur rencontre, elle donne naissance (1) une dfinition dpourvue de pointvirgule (en anglais : missing ';') et (3) une instruction mentionnant un objet non dclar (en anglais : undeclared identifier). Remarquez que la logique des deux derniers messages d'erreur n'apparat qu'aprs que l'on ait compris la cause du premier. Par consquent, Lorsque plusieurs erreurs sont signales, il faut d'abord chercher comprendre la premire.
Lorsque les erreurs signales sont nombreuses, il faut utiliser la barre de dfilement vertical pour remonter l'affichage de la premire.

J-L Pris - 23/10/07

VC++ 6.0 Fragmentation du nom

TD 2 : cration de variables

5/10

Modifiez ainsi la ligne de code dfinissant la variable int maPremiere variable; Lors de la compilation (F7)

, les messages d'erreur suivants sont mis :

A la lumire de la discussion prcdente, ces messages devraient vous sembler limpides. Oubli du point-virgule final Modifiez ainsi la ligne de code dfinissant la variable int maPremiereVariable Lors de la compilation (F7) , le message d'erreur suivant est mis : :

Il arrive que le compilateur mette un message unique dcrivant exactement l'erreur commise.
C'est cependant assez rare (l'oubli d'un seul point-virgule peut, dans certains cas, provoquer l'mission de plus de cent messages d'erreur).

Une variable initialise Modifiez le programme de faon ce que la variable soit initialise avec la valeur 67305985 .

Compilez (F7) et lancez l'excution du programme (F5) . Le programme s'arrte nouveau sur la ligne return 0, qui comporte toujours un point d'arrt. Dans le sous-menu "Debug windows" du menu "View", choisissez la commande "Memory" Cette fentre (cf. ci-contre) propose une reprsentation (en hexadcimal) du contenu de la mmoire.
L'annexe 0 propose un rappel sur la notation hexadcimale, mais la matrise de cette faon d'crire les nombres n'est pas indispensable pour l'usage que vous allez faire de la fentre "Memory".

La fentre "Memory" du debugger

La partie infrieure de la fentre "Memory" comporte trois zones : - la zone centrale contient des nombres hexadcimaux deux chiffres qui reprsentent l'tat des cases mmoires - la zone de gauche propose une colonne de nombres huit chiffres qui sont les adresses correspondant la premire case mmoire dont l'tat est reprsent sur la ligne concerne. - la zone de droite donne, pour sa part, une interprtation de l'tat de la mmoire supposant que celle-ci contient du texte. La partie suprieure de la fentre "Memory" contient une zone d'dition intitule "Address:". Effacez le contenu de cette zone et remplacez-le par le nom de votre variable . Lorsque vous pressez la touche "Entre" , les donnes affiches dans la partie infrieure de la fentre sont ajustes pour que la zone de mmoire reprsente dbute l'adresse de la variable.
J-L Pris - 23/10/07

VC++ 6.0

TD 2 : cration de variables

6/10

La fentre "Memory" reprsente ci-dessus indique donc que, au cours de l'excution du programme pendant laquelle cette photo a t prise, maPremiereVariable s'tait vu attribuer la zone de mmoire dbutant l'adresse 0x12FF2C (c'est dire 1 244 972 en dcimal). Il est, bien entendu, possible que la zone de mmoire attribue votre propre variable soit diffrente. Si vous avez bien initialis la variable avec la valeur suggre, l'tat des quatre premires cases de mmoire affiches devrait en revanche tre identique celui reprsent ci-dessus, puisque la squence 01 02 03 04 correspond au codage de 67305985 dans une variable de type int. Mettez fin l'excution du programme en choisissant, dans le menu "Debug", la commande "Stop debugging" . Erreurs d'initialisation Modifiez le programme de faon ce que votre variable, bien que de type int, soit initialise avec la valeur 3.14 . Lors de la compilation (F7) , l'avertissement (warning) suivant est mis :

Une compilation qui s'achve sans erreur produit un excutable qui fonctionne, mme si la compilation s'est accompagne d'avertissements. Lancez l'excution du programme et observez la valeur de maPremiereVariable au moment o le point d'arrt est atteint .

Etat d'une variable de type int initialise avec la valeur 3.14

L'erreur que nous venons de commettre ne rend pas la compilation impossible, car le compilateur procde une conversion automatique, qui lui permet d'obtenir la reprsentation de 3 au format int partir de la reprsentation de 3.14 au format double. Cette conversion s'accompagnant d'une perte de prcision, le compilateur met un avertissement. Remarquez toutefois qu'un programmeur qui initialise une variable avec une valeur comportant une partie dcimale n'a sans doute pas en tte la cration d'un objet contenant une valeur entire, et risque d'tre fort du par les rsultats obtenus, par la suite, en utilisant cette variable. N'ignorez pas les avertissements, ils peuvent signaler une erreur lourde de consquences. Conversion automatique Certaines conversions n'entranent aucun risque de perte de prcision, et sont donc effectues sans que le moindre avertissement ne les signale. Modifiez la dclaration de maPremiereVariable et ajoutez celle d'une seconde variable, de sorte que votre code prenne la forme suivante :
1 2

int maPremiereVariable = 3; double secondeVariable = maPremiereVariable; Aprs compilation et excution , l'tat de notre secondeVariable apparat ainsi :

Etat d'une variable de type double initialise avec la valeur 3 J-L Pris - 23/10/07

VC++ 6.0

TD 2 : cration de variables

7/10

La ligne 2 garantit que les deux variables adoptent la mme valeur. Il est pourtant clair que leur diffrence de type conduit ces variables reprsenter cette valeur de faon diffrente.
Pour procder l'initialisation de la secondeVariable, le compilateur a donc du convertir (silencieusement) la valeur trouve dans maPremiereVariable (03 00 00 00) pour lui donner la reprsentation convenant une variable de type double (00 00 00 00 00 00 08 40).

Une variable de type pointeur Modifiez la dclaration de secondeVariable, de sorte que votre code prenne la forme suivante :
1 2

int maPremiereVariable = 3; int * secondeVariable = & maPremiereVariable; Aprs compilation et excution , l'tat de notre secondeVariable apparat ainsi :

Si vous demandez la fentre "Memory" d'afficher l'tat de la zone mmoire correspondant , vous pouvez maPremiereVariable (en tapant le nom de celle-ci dans la zone "Adress") constater (dans la colonne de gauche de la fentre "Memory"), que cette zone commence effectivement l'adresse contenue dans secondeVariable (0x12FF2C, sur la copie d'cran propose ci-dessus).

3 - Cration et utilisation d'un type numr

La cration d'un type numr est extrmement simple, et la seule question qui se pose rellement est la suivante : o allons nous faire figurer sa dfinition ? Dfinition "sur place" Une premire faon de procder est d'insrer la dfinition de notre type au dbut du fichier dans lequel il est utilis. Dans notre cas, cela conduirait un texte source se prsentant ainsi :
1 2 3 4 5 6 7 8 9

// TD02.cpp : Defines the entry point for the application. #include "stdafx.h" enum EPersonnage {ROSE, MOUTARDE, LEBLANC, OLIVE, PERVENCHE, VIOLET}; int APIENTRY WinMain(HINSTANCE HINSTANCE LPSTR int { // TODO: Place code here. return 0; } hInstance, hPrevInstance, lpCmdLine, nCmdShow)

Cette mthode l'avantage d'tre simple et directe. Son dfaut est que, si des fonctions dfinies dans un autre fichier entendent, elles aussi, se servir du type EPersonnage, la dfinition de celui-ci devra galement figurer dans cet autre fichier. La rptition de dfinitions identiques cre un risque : l'accumulation des modifications apportes au texte source peut finir par rendre ces dfinitions diffrentes. Cette erreur, difficile reprer pour un lecteur humain, n'est souvent pas dtectable par le compilateur et a toutes les chances de se traduire par un fonctionnement incorrect du programme. Par consquent, On prfre habituellement viter de dfinir les types "sur place".

J-L Pris - 23/10/07

VC++ 6.0 Dfinition dans un fichier .h

TD 2 : cration de variables

8/10

L'alternative consiste crer un fichier ad hoc. La coutume veut que les fichiers contenant des dfinitions de types portent l'extension ".h". Dans le menu "File", choisissez la commande "New" . Dans l'onglet "Files" du dialogue qui s'ouvre alors, slectionnez l'option "C/C++ Header File" et, dans la zone d'dition "FileName:", saisissez le nom personnages.h , puis cliquez sur le bouton "OK" . Vous disposez alors un fichier vierge, dans lequel vous pouvez entrer votre dfinition :

//personnages.h : contient la dfinition du type EPersonnage, qui sert //crer des variables capables de reprsenter un personnage du jeu de Cluedo enum EPersonnage {ROSE, MOUTARDE, LEBLANC, OLIVE, PERVENCHE, VIOLET}; Enregistrez le fichier (commande "Save" du menu "File") et refermez-le .

Un tel fichier permet d'viter d'avoir rpter la dfinition du type numr : chaque fois que vous aurez besoin d'utiliser celui-ci, il vous suffira d'indiquer dans quel fichier se trouve sa dfinition. Cette indication est donne en faisant figurer, en dbut de fichier, la directive #include "personnages.h" N'insrez jamais vos propre directives #include avant le #include "stdafx.h" de Visual C++ Utilisation Une fois le type dfini, il s'utilise exactement comme un type standard. Corrigez le code (sans erreur ni avertissement). suivant, de faon ce que le programme puisse tre compil // TD02.cpp : Defines the entry point for the application. // #include "stdafx.h" #include "personnages.h" int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow) { // TODO: Place code here. EPersonnage moi = MOUTARDE EPersonnage suspectPrincipal(PERVANCHE); EPersonnage autreSuspect = MOI; return 0; }
Si le compilateur se plaint que EPersonnage est un "undeclared identifier", c'est sans doute que vous avez oubli d'insrer la ligne 2 C'est parce que les directives #include figurent normalement au dbut des textes source que les fichiers sur lesquels elles portent sont nomms des "headers" (fichiers d'en-tte, en franais). Cette dnomination est, a son tour, la cause du choix de l'extension .h

1 2 3 4 5 6 7 8 9 10 11 12

4 - Cration et utilisation d'une classe

En l'tat actuel de vos connaissances, la cration d'une classe n'est pas trs diffrente de la cration d'un type numr. Ds la Leon prochaine, toutefois, les classes vont comporter des fonctions membre, et il ne sera plus du tout envisageable de les dfinir "sur place".
Si les types (classes ou types numrs) peuvent tre redfinis dans le mme programme autant de fois qu'il est ncessaire (lorsqu'ils sont utiliss par des fonctions places dans des fichiers diffrents, par exemple), ce n'est pas le cas des fonctions membre (qui ne peuvent tre dfinies qu'une seule fois). Cette contrainte nous force pratiquement utiliser des fichiers spcifiques pour dfinir les classes.
J-L Pris - 23/10/07

VC++ 6.0 Dfinition

TD 2 : cration de variables

9/10

En vous inspirant de la procdure suivie pour le type numr, crez un fichier nomm "position.h" . Placez dans ce fichier le code suivant
1 2 3 4 5 6 7

class CPosition { public: double latitude; double longitude; int altitude; }; Enregistrez le fichier Instanciation

//en degrs //en degrs //en mtres et refermez-le .

Modifiez le code prsent dans le fichier TD02.CPP de faon ce que la fonction WinMain() comporte une variable de type CPosition .
Vous n'tes pas, pour l'instant, en mesure d'initialiser cette variable.

Vrifiez que votre code peut tre compil sans erreur ni avertissement

5 - Cration de rfrences
L'attribution d'un second nom une variable suppose, bien entendu l'existence pralable de : cette variable. Insrez donc le code suivant dans votre fonction WinMain()
1 2

int ageDuCapitaine = 15; int & adc = ageDuCapitaine; Vrifiez que ce code peut tre compil sans erreur ni avertissement Problmes de conformit des types Outre l'omission pure et simple de l'initialisation de la rfrence (qui provoque videmment une erreur de compilation : "references must be initialized"), le seul problme que vous risquez de rencontrer lors de la cration d'une rfrence est une divergence entre le type dclar pour celle-ci et celui de l'objet qu'elle est cense dsigner. Essayez, par exemple, .

1 2 3

int ageDuCapitaine = 15; double age = ageDuCapitaine; double & adc = ageDuCapitaine; La compilation de cette squence de code provoque l'mission d'un message d'erreur :

La ligne 2 ne cre pas de problme, car une conversion automatique de la valeur 15 contenue dans ageDuCapitaine produit la valeur 15.0, qui peut tre stocke dans la variable age. Le cas de la ligne 3 est bien diffrent, car il ne s'agit pas l de ranger une valeur dans une variable, mais d'associer un nouvel identificateur la variable ageDuCapitaine. Cette variable tant un int, il n'est pas question de lui associer un identificateur qui laisserait croire qu'il s'agit d'un double.
Le message d'erreur mis par le compilateur est accompagn d'une remarque rappelant qu'une rfrence un objet non constant ne peut tre associe un objet non modifiable. Cette remarque peut sembler hors sujet, dans la mesure o la ligne 3 ne mentionne aucun
J-L Pris - 23/10/07

VC++ 6.0

TD 2 : cration de variables

10/10

objet non modifiable. Il faut, pour la comprendre, savoir qu'une rfrence un objet constant peut tre associe une constante littrale : const double & CONSTANTE = 15; //une faon exotique de crer une constante Si la ligne 3 de l'exemple prcdent avait t const double & adc = ageDuCapitaine; le compilateur aurait tout simplement associ l'identificateur adc une constante double de valeur 15.0 (valeur obtenue par conversion automatique de celle contenue dans ageDuCapitaine). L'erreur rencontre sur la ligne 3 peut donc avoir deux origines : soit le programmeur souhaitait crer un surnom pour ageDuCapitaine (et il a crit double au lieu d'int), soit le programmeur souhaitait crer une constante de type double initialise avec la valeur courante de la variable ageDuCapitaine (et il a oubli le mot const). C'est cette seconde hypothse que fait allusion la remarque mise par Visual C++.

6 - Qu'avons nous appris ?

1 - Un programme peut tre dpourvu de toute interface utilisateur. 2 - Les variables non initialises sont dans un tat imprvisible. 3 - Le nombre d'erreurs signales par le compilateur n'est pas le nombre d'erreurs contenues dans le code source. 4 - Il faut toujours commencer par corriger la premire erreur signale. 5 - Error(s) et warning(s) mritent le mme traitement : il faut liminer leur cause. 6 - On dfinit un type (classe ou type numr) dans un fichier .h 7 - Pour pouvoir utiliser un type dfini dans un autre fichier, il faut "#includer" le fichier en question.

J-L Pris - 23/10/07