programmation en langage c c++ - 107 pages
Post on 02-Apr-2018
230 Views
Preview:
TRANSCRIPT
-
7/27/2019 Programmation en Langage c c++ - 107 Pages
1/107
Programmation en Langage C/C++
par Sylvain Ferey
pour le Forum des Programmeurs Francophones
-
7/27/2019 Programmation en Langage c c++ - 107 Pages
2/107
Tables des matires
Introduction............................................................................................................................. 5
Ralisation de notre premier programme C............................................................................... 6
Les types du C / C++.............................................................................................................. 9
Le type caractre .................................................................................................................9
Un signe de caractre ..............................................................................................................................................9
Les types entiers.................................................................................................................13
Les entiers courts ...................................................................................................................................................13
Les entiers longs....................................................................................................................................................13
Les types flottants...............................................................................................................15
Conversion de types............................................................................................................15
Le type Pointeur ........ ......... ........ ......... ........ ......... ........ ......... ......... ........ ......... ........ ......... ..17
Le type Tableau..................................................................................................................23
Les tableaux statiques ...........................................................................................................................................23
Les tableaux dynamiques......................................................................................................................................25
Les tableaux de caractres ....................................................................................................................................27
Les oprateurs....................................................................................................................... 28
Les oprateurs mathmatiques.............................................................................................28
Les oprateurs logiques et relationnels....... ......... ........ ......... ........ ......... ........ ......... ........ ....... 30
Les oprateurs dincrmentation et dcrmentation....... ........ ......... ........ ......... ........ ......... .....31
Les oprateurs binaires ........ ......... ........ ......... ........ ......... ........ ......... ......... ........ ......... ........ .32
Les oprateurs contracts ...................................................................................................33
Les piges viter..............................................................................................................33
Les instructions de tests.......................................................................................................... 35
Linstruction if.................................................................................................................35
Lexpression condition..........................................................................................................................................37
Des conditions avec et et ou........................................................................................................................39
Loprateur ternaire ?: ......... ........ ......... ......... ........ ......... ........ ......... ........ ......... ........ ....... 39
Linstruction switch ......... ........ ......... ........ ......... ........ ......... ......... ........ ......... ........ ......... ..41
Les instructions de boucles..................................................................................................... 43Linstruction while...........................................................................................................43
Linstruction break...........................................................................................................43
Linstruction do ... while( )...............................................................................................45
Linstruction for...............................................................................................................47
Lexpression dinitialisation .................................................................................................................................47
Lexpression de test...............................................................................................................................................47
Lexpression dincrmentation.............................................................................................................................49
Linstruction continue.......................................................................................................51
-
7/27/2019 Programmation en Langage c c++ - 107 Pages
3/107
Tables des matires
Les fonctions ......................................................................................................................... 53
Dclaration.........................................................................................................................53
Dfinition ........ ......... ........ ......... ........ ......... ........ ......... ......... ........ ......... ........ ......... ........ ....55
Librairie .............................................................................................................................59
La fonction main..............................................................................................................60
Code de retour........................................................................................................................................................60
Paramtres reus ....................................................................................................................................................61
La sortie des donnes ............................................................................................................ 63
La fonction printf.............................................................................................................63
Dfinition des donnes .........................................................................................................................................63
Modificateur de description.................................................................................................................................65
Largeur daffichage................................................................................................................................................67
Prcision daffichage.............................................................................................................................................69
Modificateur de taille.............................................................................................................................................71
Les fonctions ?printf........................................................................................................71
La saisie des donnes............................................................................................................. 73
La fonction scanf.............................................................................................................73
Dfinition des donnes .........................................................................................................................................73
Suppression daffectation ....................................................................................................................................75
Largeur de lecture ..................................................................................................................................................77
Modificateurs de taille...........................................................................................................................................77
Les fonctions ?scanf........................................................................................................79
Les chanes de caractres....................................................................................................... 80
Un nombre sign ou non......................................................................................................80
Les tableaux de caractres..................................................................................................82
Les fonctions standards de manipulation de chanes...............................................................88
Comparaison...........................................................................................................................................................88
Concatnation ........................................................................................................................................................88
Copie ........................................................................................................................................................................88
Longueur.................................................................................................................................................................90
Recherche................................................................................................................................................................90
Les Fichiers........................................................................................................................... 91
Le type FILE ..................................................................................................................91
Dsignation du fichier..........................................................................................................93
Ecriture de fichier...................................................................................................................................................94
Lecture de fichier....................................................................................................................................................96
Les fonctions gnriques dentre sortie ........ ......... ........ ......... ......... ........ ......... ........ ......... ..98
Les fonctions orientes fichiers............................................................................................98
Conclusion........................................................................................................................... 102
-
7/27/2019 Programmation en Langage c c++ - 107 Pages
4/107
Liste des programmes
Code 1 : Hello world...............................................................................................................6
Code 2 : Mauvais passage de paramtres variants ........ ......... ........ ......... ......... ........ ......... ........ .21
Code 3 : Bon passage de paramtres variants........... ......... ........ ......... ........ ......... ........ ......... .....21
Code 4 : Cration dun tableau de taille quelconque....................................................................25Code 5 : Boucle while(..) { ... }........ ......... ........ ......... ........ ......... ........ ......... ........ ......... ........ 43
Code 6 : Boucle while(..) { ... } avec sortie par break..........................................................43
Code 7 : Boucle do { ... } while(..) ......... ........ ......... ........ ......... ......... ........ ......... ........ ......... ..45
Code 8 : Boucle for ........ ........ ......... ......... ........ ......... ........ ......... ........ ......... ........ ......... ........ 49
Code 9 : Boucle for avec break et continue........ ........ ......... ......... ........ ......... ........ ......... ..51
Code 10 : Fichier de dclaration : geometry.h ........ ......... ........ ......... ........ ......... ........ ......... .....55
Code 11 : Fichier de dfinition : geometry.c............................................................................57
Code 12 : Utilisation de la librairie : geometry.a.......................................................................59
Code 13 : Valeur retourne par la fonction main ........ ......... ........ ......... ......... ........ ......... ........ .60
Code 14 : Lecture du code retourn par la fonction main.........................................................60
Code 15 : Paramtres reus par la fonction main ......... ........ ......... ........ ......... ........ ......... ........ 61Code 16 : Affichage format de nombres dcimaux........ ........ ......... ........ ......... ........ ......... ........ 69
Code 17 : Stockage de donnes formates dans une chane ........ ......... ........ ......... ........ ......... .....71
Code 18 : Saisie avec cho.......................................................................................................75
Code 19 : Lecture de donnes formates depuis une chane........................................................79
Code 20 : Table ASCII restreinte..............................................................................................80
Code 21 : Table ASCII complte ......... ......... ........ ......... ........ ......... ........ ......... ........ ......... ........ 80
Code 22 : Table ASCII vraiment complte ........ ........ ......... ......... ........ ......... ........ ......... ........ ....82
Code 23 : Ecriture de fichier.....................................................................................................94
Code 24 : Lecture de fichier.....................................................................................................96
Code 25 : Carnet dadresses............. ......... ........ ......... ........ ......... ......... ........ ......... ........ ......... 102
-
7/27/2019 Programmation en Langage c c++ - 107 Pages
5/107
Sylvain Ferey (sferey@compuserve.com) 5
Forum des Programmeurs Francophones
Introduction
Ce document fait la synthse des cours de C proposs sur le Forum des Programmeurs
Francophones de CompuServe.
Cette synthse se veut un guide dapprentissage efficace du langage C ANSI.
Tous les chapitres ont t peu ou prou rcrits pour tre les plus comprhensibles
possibles et vous permettront de comprendre la mise en uvre et lutilisation du C.
Dautres chapitres ont t ajouts par rapport la parution hebdomadaire initiale.
Enfin de nouveaux exemples illustrent cette prsentation.
Ce cours est destin aux dbutants, bien quil puisse servir de rfrence aux inities.
Si vous ne disposez pas de compilateur C, vous trouverez, sur le Forum desProgrammeurs Francophones de CompuServe, une distribution du compilateur GNU
adapte au processeur Intel par DJGPP; ce compilateur ligne de commande fournit du
code binaire 32 bits de bonne qualit.
Je tiens remercier Julien Hardelin pour sa relecture efficace, ainsi que tous ceux qui,
par leurs remarques, ont contribu amliorer ce cours.
Ce document est libre dutilisation et de diffusion non commerciale sous une forme
imprime qui respecte lintgralit du document. Toute diffusion lectronique - autre
que celles ralises par lauteur lui -mme - est interdite sans laccord de lauteur.
Lauteur ne garantit pas que ce document ne contient aucune erreur ou inexactitude,
malgr les diffrentes relectures. De mme, lauteur ne pourra tre tenu pour
responsable de tout dommage, implicite ou explicite, survenant de lutilisation de ce
document et des exemples de codes quil contient.
Lauteur,
Sylvain FEREY
sferey@compuserve.com
-
7/27/2019 Programmation en Langage c c++ - 107 Pages
6/107
Sylvain Ferey (sferey@compuserve.com) 6
Forum des Programmeurs Francophones
Ralisation de notre premier programme C
En C, plus quavec dautres langages, le premier programme traditionnel est :
Code 1 : Hello world
#include
void main(){
printf("hello world!\n");
}
Pour excuter ce premier programme C, enregistrez le source ci-dessus dans un fichier
et sauvegardez le sous le nom hello.c (ou ce que vous souhaitez, mais si vous utilisez
le compilateur GNU lextension doit tre .c); ensuite dans une fentre Dos - si vous
tes sous Windows - ou avec votre shell prfr (zsh, csh, bash, ...), placez vous dans le
rpertoire qui contient ce fichier et lancez la compilation et ldition de liens grce la
commande, si vous tes sous Dos/Windows :
G:\>gcc hello.c -o hello.exe
ou si vous tes sous unix ou Linux.
> gcc hello.c -o hello
Par cette commande, nous demandons loutil gcc de compiler notre source hello.c et
de crer un excutable nomm hello.exe (ou hello); loption -o (pour output)
permettant de dfinir ce nom. Nous obtenons un programme que nous pouvons lancer,
sur lcran (la console) saffiche :
hello world!
Dtaillons ce petit programme :
?? la premire ligne inclut le fichier nomm stdio.h.
Ce fichier contient les dfinitions pour les oprations standards dentres (input)
partir du clavier ou dun fichier, et de sorties (output) vers lcran ou dans un
fichier.
stdio.h dfinit notamment une fonction nomme printf(). Cette fonction peut
tre appele avec une chane de caractres (entre guillemets - ou double quote)
comme unique paramtre; cette chane est alors affiche lcran.
?? nous trouvons ensuite une unique fonction appele main.
Cette fonction est le point dentre du programme; cest dire l o dbutera son
excution; elle est appele fonction principale.
Le nom de cette fonction - main - est impos, si vous en utilisez un autre,
lditeur de liens (linkeur) vous dira quil na pas trouv de fonction main et la
construction de lexcutable chouera.
main est une fonction, nous devons donc placer une paire de parenthses
ouvrante et fermante - ( et ) - aprs son nom. Dans cet exemple simple, la
fonction ne reoit aucun paramtre, rien ne figure donc entre ces parenthses.
-
7/27/2019 Programmation en Langage c c++ - 107 Pages
7/107
Sylvain Ferey (sferey@compuserve.com) 7
Forum des Programmeurs Francophones
Une fonction doit dfinir le type des informations quelle retourne, comme ici
aucune valeur nest retourne par la fonction main, nous utilisons le mot cl
void (littralement rien) plac devant le nom de la fonction.
-
7/27/2019 Programmation en Langage c c++ - 107 Pages
8/107
Sylvain Ferey (sferey@compuserve.com) 8
Forum des Programmeurs Francophones
Enfin le corps dune fonction est toujours dfini entre accolades { et }. Ici, il est
constitu dun simple appel la fonction printf() qui nous communiquons le
texte afficher. Notez dans notre message que le caractre \n sert insrer un
retour la ligne la fin du texte.
Notez que la syntaxe est importante. Le C et le C++ distinguent les minuscules des
majuscules. Dans ce source, seul le texte entre parenthses aurait pu avoir unesyntaxe diffrente, tout le reste doit tre tap en minuscule.
En effet, include et void font parti des mots cl du langage et leur syntaxe est
impose. La routine printf est dclare avec cette orthographe dans le fichier stdio.h
et est implmente avec ce nom dans la librairie dentre/sortie. Enfin la librairie de
dmarrage (le runtime) sattends trouver une fonction nomme main.
Remarque: le systme Dos/Windows ne distinguant pas la casse des noms de fichiers
stdio.h aurait pu tre saisi autrement. Cependant une des forces du C/C++ tant sa
portabilit, il est trs recommand de respecter la syntaxe des noms de fichiers afin de
pouvoir recompiler vos sources sur dautres plates-formes (sous unix, par exemple).
-
7/27/2019 Programmation en Langage c c++ - 107 Pages
9/107
Sylvain Ferey (sferey@compuserve.com) 9
Forum des Programmeurs Francophones
Les types du C / C++
Les langages C et C++ sont des langages typs.
Cela signifie que pour utiliser une variable, vous devez, avant de pouvoir lutiliser,
dclarer cette variable en prcisant son type.
Il existe trois sortes de types fondamentaux : le type caractre, le type entier et le type
rel ou flottant.
Nous allons tudier chacun de ces types. Notons avant cela lexistence dun autre type
particulier et que nous venons de rencontrer : le type void, ce type ne peut tre utilis
que comme type dune fonction (qui ne renvoie rien); en effet il est impossible de
dclarer une variable qui ne serait stock sur aucun octet et qui ne permettrait de
stocker aucun nombre.
Le type caractre
Le type caractre permet de dfinir des variables stockant une lettre. Le nom de ce type
est char; on dfinit donc ainsi une variable de type caractre :
char maLettre;
Nous pouvons ensuite fixer la valeur dune telle variable avec une lettre donne entre
apostrophes (ou simple quote), voici un exemple :
maLettre = 'a';
Notez dans cet exemple que le signe = sert dfinir la valeur dune variable ( lui
affecter une valeur). Nous dirons que = est loprateur daffectation.
Nous pouvons galement dclarer une variable et fixer sa valeur en mme temps:
char maLettre = 'A';
Nous pouvons galement dfinir la valeur dune variable de type char avec une valeur
numrique. En effet, dans le dernier exemple la lettre 'A' est un caractre appartenant
au jeu de caractres ASCII a pour valeur le nombre 65. Nous pouvons donc coder la ligne
ci-dessus :
char maLettre = 65;
Plus gnralement, le type char supporte in extenso larithmtique des nombres entiers;ceci est trs commode et vite les surcharges (modifications de types) ou appels des
fonctions manipulant les caractres comme cest le cas en Pascal; par exemple le code
suivant affecte un caractre le caractre suivant dans le jeu de caractres utilis :
char uneLettre = 'A';
uneLettre = uneLettre + 1; /* lettre contient 'B' */
Notez que les symboles /* et */ permettent dinsrer des commentaires.
Un signe de caractre
Le type char stockant des caractres est cod sur un octet, il accepte donc 256 valeurs
diffrentes, mais quelles valeurs ?
-
7/27/2019 Programmation en Langage c c++ - 107 Pages
10/107
Sylvain Ferey (sferey@compuserve.com) 10
Forum des Programmeurs Francophones
Il existe en fait deux types char, lun est sign et peut contenir des valeurs comprises
entre -128 et +127; le second est non sign et ne contient donc que des valeurs positives
soit les nombres compris entre 0 et 255.
Ces deux types sont dfinis par les noms signed char et unsigned char.
-
7/27/2019 Programmation en Langage c c++ - 107 Pages
11/107
Sylvain Ferey (sferey@compuserve.com) 11
Forum des Programmeurs Francophones
Le type char (sans plus de prcision) comme nous lavons utilis prcdemment est
gnralement quivalent au type signed char, mais cela peut changer selon la machine
hte. En effet, ce type a en quelque chose t dfini pour reprsenter tous les caractres
disponibles sur un systme donn.
Cette dfinition date un peu; cette poque la plupart des systmes ne dfinissaient
que les caractres dont la valeur est comprise entre 0 et 127, cest notamment le cas dujeu de caractres ASCII primordial et du jeu de caractres EBCDIC (des IBM 370, par
exemple), le problme de la reprsentation du type char (sign ou non sign) ne se posait
alors pas.
Aujourdhui tous les compilateurs permettent de dfinir explicitement un type caractre
sign (grce signed char) et non sign (grce unsigned char), le type char restant le
format natif du systme hte. Cette distinction permet, grce aux contrles des types
effectus par le compilateur de traiter ces types distinctement et ceci peut savrer trs
utile.
Illustrons ce point par un exemple: les chanes de caractres en C sont des tableaux de
char. Ces chanes sont termines par un caractre de valeur nulle (ou encore de valeur
ASCII zro, on parlera de chane ASCIIZ); imaginons un programme qui aurait besoin de
stocker et manipuler de s chanes qui, comme en Pascal, contiennent la longueur de la
chane comme premier caractre, nous pouvons reprsenter de telles chanes comme
un tableau de unsigned char; grce cela le compilateur fera bien la diffrence entre
ces deux sortes de chanes et il nous avertira dune ventuelle erreur si nous utilisons
une chane ASCIIZ l o une chane Pascal est attendue et vice versa.
La distinction entre une variable signe et non signe ninfluence pas le stockage de la
valeur de cette variable, ainsi si nous codons :
signed char lettreSigne = 'a';unsigned char lettreNonSigne = 'a';
alors ces deux variables contiennent, du point de vue binaire, exactement les mmes
donnes; par contre larithmtique applique ces variables sera diffrente; on
distinguera ainsi une arithmtique signe et une autre non signe; expliquons cela :
Soit la dfinition:
signed char lettreSigne = 127;
unsigned char lettreNonSigne = 127;
si maintenant nous ralisons :
lettreSigne = lettreSigne + 1;
lettreNonSigne = lettreNonSigne + 1;
alors la variable lettreSigne est maintenant interprte par une opration
arithmtique comme -128, tandis que la variable lettreNonSigne serait interprte
comme 128.
Voici un autre exemple, nous dfinissons :
signed char lettreSigne = 0;
unsigned char lettreNonSigne = 0;
si maintenant nous ralisons :
lettreSigne = lettreSigne - 1;
lettreNonSigne = lettreNonSigne - 1;
-
7/27/2019 Programmation en Langage c c++ - 107 Pages
12/107
Sylvain Ferey (sferey@compuserve.com) 12
Forum des Programmeurs Francophones
alors la variable lettreSigne est interprte comme -1, tandis que lettreNonSigne est
interprte comme +255.
Notez enfin que le type char est bien un type distinct de signed char et de unsigned
char; cette rgle ne sapplique pas aux types entiers que nous allons dtailler et pour
lesquels si la spcification signed ou unsigned est omise, le type est considr comme
signed.
-
7/27/2019 Programmation en Langage c c++ - 107 Pages
13/107
Sylvain Ferey (sferey@compuserve.com) 13
Forum des Programmeurs Francophones
Les types entiers
Les types entiers sont tous bass sur le type fondamental int; cependant le codage de ce
type dpend de la machine et du compilateur utilis.
Aussi, et bien que lemploi du mot cl int soit suffisante pour dclarer une variable
entire, nous utiliserons les modificateurs de types short et long pour dfinir le formatdes nombres entiers dune manire qui ne dpende plus de lenvironnement
Les entiers courts
Le modificateur short, utilis en association avec int, permet de dfinir un entier cod
sur 16 bits ou deux octets. Nous pouvons ici aussi utiliser en plus les modificateurs
signed et unsigned, ceci nous conduit aux types suivants :
signed short int nombres compris entre -32 768 et +32767
unsigned short int nombres compris entre 0 et 65 535
pour simplifier lcriture le symbole int peut tre omis; ainsi les deux dfinitions de
types prcdentes sont quivalentes signed short et unsigned short; de plus, comme
nous venons de le voir avec le type char, la reprsentation signed est implicite pour des
entiers si rien nest prcis; nous utiliserons donc: short (nombre de -32 768 +32767)
et unsigned short (nombre de 0 65 535).
Voici des dfinitions valides de variables entires :
short unEntier;
signed short unNombre; /* quivalent short unNombre */
signed short intunChiffre; /* quivalent short unChiffre */
unsigned shortunEntierPositif;
Les entiers longs
Le modificateur long, utilis en association avec int, permet de dfinir un entier cod
sur 32 bits ou quatre octets, cet entier peut galement tre sign ou non, soit les types :
signed long int nombres compris entre -2 147 483 648 et 2 147 483 647
unsigned long int nombres compris entre 0 et 4 294 967 295
Comme prcdemment, les mots cl int et signed sont optionnels, nous utiliserons les
dfinitions de type long et unsigned long.
Voici des dfinitions valides de variables entires longues :
long unGrandEntier;
signed long unGrandNombre; /* quivalent long unGrandNombre */
signed long int unGrandChiffre; /* quivalent long unGrandChiffre */
unsigned long unGrandEntierPositif;
Le modificateur long peut tre appliqu deux fois au type int, ainsi nous dfinissons un
type entier cod sur 64 bits ou 8 octets, soit les types :
signed long long int
unsigned long long int
-
7/27/2019 Programmation en Langage c c++ - 107 Pages
14/107
Sylvain Ferey (sferey@compuserve.com) 14
Forum des Programmeurs Francophones
que nous utiliserons comme long long et unsigned long long; le type long long accepte
des valeurs comprises entre -9 223 372 036 854 775 808 et 9 223 372 036 854 775 807;
soit presque de quoi compter le nombre de particules prsentes dans tout lunivers.
-
7/27/2019 Programmation en Langage c c++ - 107 Pages
15/107
Sylvain Ferey (sferey@compuserve.com) 15
Forum des Programmeurs Francophones
Les types flottants
Ces types servent reprsenter des nombres en virgule flottante, cest dire des rels.
La prcision de telles variables (cest dire le nombre de chiffres significatifs) et leurs
valeurs absolues minimale et maximale dpendent du processeur sur lequel tourne le
code ainsi que, dans certains cas, du compilateur.
Les types dfinis sont :
float flottant simple prcision
double flottant double prcision
long double flottant quadruple prcision
Le type float correspond gnralement la taille des registres du processeur, le type
double est deux fois plus large (ncessite deux fois plus doctets) et le type long double
quatre fois plus.
Ainsi sur les processeurs Intel rcents, le type float est cod sur 4 octets et permet de
stocker des nombre dont la valeur absolue est comprise entre 1.403e-45 et -3.403e+38.
Le type double est lui cod sur 8 octets et reprsente une valeur absolue comprise entre
4.941e-324 et 1.798e+308.
Par contre, sur un Cray utilisant des processeurs 64 bits le type float est stock sur 8
octets (et correspond donc au type double utilisable avec un processeur Intel) tandis que
le type double est cod sur 16 octets.
Enfin le type long double est totalement dpendant du compilateur (car certain ne le
dfinisse pas) et du processeur utilis (il peut ainsi tre cod sur 10, 16 ou 32 octets).
Notez que les modificateurs signed et unsigned ne sont pas applicables aux types
flottants; ceux-ci dfinissent toujours des variables ayant un signe.
Conversion de types
Les langages C et C++ supportent la modification de types (typecasting) des valeurs.
Cette modification est implicite (automatique) entre les types fondamentaux que nous
venons dtudier; ainsi le code suivant est valide :
float monReel = 97.85;
short monEntier = monReel; /* monEntier vaut 97 */char maLettre = monEntier; /* maLettre est 'a' */
cependant le compilateur risque dmettre des avertissements durant la compilation de
ce code afin de nous avertir des risques de pertes de donnes.
Pour viter ces messages et lorsque nous savons que le codage ralis est correct, nous
pouvons raliser une conversion explicite (demande) des donnes, ainsi nous cririons:
float monReel = 97.85;
short monEntier = (short) monReel;
char maLettre = (char) monEntier;
avec une telle criture nous demandons une conversion du type de donnes de lavariable vers le type prcis. La variable dorigine et son type demeure inchangs
(monReel est toujours une variable de type float) mais lexpression rsultat que
-
7/27/2019 Programmation en Langage c c++ - 107 Pages
16/107
Sylvain Ferey (sferey@compuserve.com) 16
Forum des Programmeurs Francophones
reprsente son valuation (cest dire sa valeur) est convertie lors de la ralisation de
laffectation. Rptons-le cest exactement ce que le compilateur a ralis lors dune
conversion implicite mais maintenant la compilation est plus propre puisque quaucun
avertissement ne sera affich pour ces lignes, ce qui nous aidera apporter plus
dattention aux autres messages du compilateur.
-
7/27/2019 Programmation en Langage c c++ - 107 Pages
17/107
Sylvain Ferey (sferey@compuserve.com) 17
Forum des Programmeurs Francophones
Le type Pointeur
Les variables de type pointeur permettent de stocker non plus une donne (comme une
lettre, un entier ou un nombre rel) mais ladresse dune autre variable.
Pour utiliser une telle variable, nous dfinirons donc sa valeur avec ladresse dune
variable existante; pour cela nous utiliserons loprateur & (oprateur rfrence) quiappliqu une variable fournit son adresse; cest dire lendroit o la valeur de cette
variable est stocke en mmoire.
Si nous avons dfini :
short unEntier;
alors :
&unEntier
fournit ladresse de cette variable.
Notez que loprateur & ne peut pas tre appliqu sur des expressions values. Par
exemple &(unEntier + 1) est interdit, de mme que &32; en effet, dans ces
expressions (unEntier + 1 ou le nombre 32) nexistent pas comme des emplacements
mmoires dfinis, il est donc impossible den valuer ladresse.
La variable pointeur elle-mme sera dfinie en utilisant le symbole * qui associ un
type dfinit le pointeur sur ce type. Nous dirons en effet que cette variable pointe sur
une donne, car contrairement une variable non-pointeur, elle ne contient pas
directement la donne mais seulement ladresse o cette donne est stocke.
Voici des dfinitions de variables pointeurs :
short* adresseDunEntier;
char* adresseDunCaractere;
unsigned long* adresseDunEntierPositif;
Notez que le fait de coller le symbole * droite du nom du type est arbitraire, en effet
les dclarations suivantes sont rigoureusement identiques aux prcdentes :
short *adresseDunEntier;
char *adresseDunCaractere;
unsigned long *adresseDunEntierPositif;
Selon votre propre prfrence vous utiliserez la premire en explicitant littralement
linstruction short* adresseDunEntier comme adresseDunEntier est une variabledont le type est short* cest dire pointeur sur un short; ou bien considrant la forme
short *adresseDunEntier vous pourrez vous dire *adresseDunEntier est une variable
pointeur qui pointe sur une variable de type short; les deux sont tout fait quivalents.
Pour stocker ladresse de notre variable unEntier nous faisons donc :
short unEntier;
short* adresseDunEntier;
adresseDunEntier = &unEntier;
Comme pour une variable non -pointeur, nous pouvons dclarer notre variable pointeuret fixer sa valeur en mme temps, soit :
-
7/27/2019 Programmation en Langage c c++ - 107 Pages
18/107
Sylvain Ferey (sferey@compuserve.com) 18
Forum des Programmeurs Francophones
short unEntier;
short* adresseDunEntier = &unEntier;
-
7/27/2019 Programmation en Langage c c++ - 107 Pages
19/107
Sylvain Ferey (sferey@compuserve.com) 19
Forum des Programmeurs Francophones
Pour lire la valeur pointe par une variable pointeur, nous utiliserons le signe *
gauche du nom de la variable pointeur; cette opration sappelle drfrencer le
pointeur et le symbole * est loprateur dadressage.
Ainsi pour obtenir la valeur pointe par adresseDunEntier nous utilisons :
*adresseDunEntier
cette criture est lorigine de la prfrence souvent rencontre pour la seconde forme
de dfinitions des pointeurs vue ci-dessus.
Appliquons cela :
short unEntier; /* dclaration dun entier court */
short unNombre; /* un autre entier court */
short* unPointeur; /* un pointeur sur un entier court */
unEntier = 5; /* fixe la valeur de unEntier */
unPointeur = &unEntier; /* stocke ladresse de unEntier */
unNombre = *unPointeur; /* rcupre la donne pointe: 5 */
Notez que ce code est quivalent :
short unEntier; /* dclaration dun entier court */
short unNombre; /* un autre entier court */
unEntier = 5; /* fixe la valeur de unEntier */
unNombre = unEntier; /* prend directement la valeur */
Cet exemple montre un cas o il semble inutile dutiliser un pointeur, dans un vrai code
son usage se rvlerait indispensable; imaginez par exemple quau lieu daffecter la
variable unPointeur avec ladresse de unEntier nous devons raliser un test pour
choisir parmi plusieurs variables celle dont nous stockerons ladresse; lutilisation dunpointeur permet alors dutiliser la donne de la variable choisie sans devoir raliser ce
test chaque fois.
De plus nous pouvons utiliser la variable pointeur pour modifier le contenu de la variable
pointe, par exemple :
short entier1; /* dclaration dun entier court */
short entier2; /* un autre entier court */
short entier3; /* un autre entier court */
etc...
short* unPointeur; /* un pointeur sur un entier court */
un test conduirait par exemple :
unPointeur = &entier2; /* stocke ladresse de entier2 */
*unPointeur = 5; /* fixe la donne pointe 5 */
maintenant entier2 vaut 5
Une autre mise en oeuvre incontournable des pointeurs est lutilisation de paramtres
variants avec une fonction. Paramtre variant signifie que vous dsirez passer une
variable une fonction et vous souhaitez que cette fonction puisse modifier le contenu
de cette variable.
Un exemple pourrait tre une fonction utilise lors dun tri; nous souhaitons crire une
fonction qui reoit deux nombres a et b et le cas chant permute ces deux nombres
afin que a soit infrieur ou gal b.
-
7/27/2019 Programmation en Langage c c++ - 107 Pages
20/107
Sylvain Ferey (sferey@compuserve.com) 20
Forum des Programmeurs Francophones
Si nous dfinissons simplement le type des paramtres transmis cette routine comme
tant des types non pointeur, nous ne recevrons que la valeur de la variable et le
traitement effectu sera perdu la sortie de la fonction.
Ainsi le programme suivant ne marche pas !
-
7/27/2019 Programmation en Langage c c++ - 107 Pages
21/107
Sylvain Ferey (sferey@compuserve.com) 21
Forum des Programmeurs Francophones
Code 2 : Mauvais passage de paramtres variants
#include
voidpermute(short a, short b) {
short temp;
if (a > b){
temp = a;a = b;
b = temp;
}
}
voidmain(){
short x, y; /* dclaration de deux entiers courts */
x = 5;
y = 2;
printf("%hd %hd\n", x, y); /* affiche les nombres */
permute(x, y); /* appel de notre fonction */
printf("%hd %hd\n", x, y); /* affiche les nombres */
}
A lexcution, nous obtenons deux fois laffichage de :
5 2
Remarque : ne vous effrayez pas de lexpression printf("%hd %hd\n", x, y). Cette
commande permet dafficher les deux nombres x et y; nous tudierons cela plus loin.
Pour obtenir, le rsultat souhait nous devons transmette notre fonction ladresse des
variables afin que ce soit bien le contenu de ces variables qui soit chang.
Pour cela notre routine dclare des paramtres de type short* et non plus short, nous
sommes donc oblig de drfrencer ces variables afin de lire la valeur pointe et lors de
lappel cette routine nous devons transmettre les adresses grce loprateur &.
Voila la version corrige du programme :
Code 3 : Bon passage de paramtres variants
#include
voidpermute(short* a, short* b) {
short temp;
if (*a > *b){
temp = *a;
*a = *b;
*b = temp;
}
}
voidmain(){
short x, y; /* dclaration de deux entiers courts */
x = 5;
y = 2;
printf("%hd %hd\n", x, y); /* affiche les nombres */
permute(&x, &y); /* appel de notre fonction */
printf("%hd %hd\n", x, y); /* affiche les nombres */
}
A lexcution, nous obtenons laffichage suivant :
-
7/27/2019 Programmation en Langage c c++ - 107 Pages
22/107
Sylvain Ferey (sferey@compuserve.com) 22
Forum des Programmeurs Francophones
5 2
2 5
-
7/27/2019 Programmation en Langage c c++ - 107 Pages
23/107
Sylvain Ferey (sferey@compuserve.com) 23
Forum des Programmeurs Francophones
Le type Tableau
Un tableau est une variable qui permet de stocker non plus une seule valeur mais un
nombre fini et dtermin de valeurs.
Il est possible de crer des tableaux dlments quelconques, par exemple des tableaux
de caractres - nous y reviendrons en dtail plus loin - ou encore des tableaux dentiersou de rels; nous pouvons galement dfinir des tableaux de variables pointeurs et
mme des tableaux de fonctions, mais commenons par le dbut.
Les tableaux statiques
Un tableau statique est un tableau dont la taille (le nombre dlments) est fige et
dclare dans le source.
Un tel tableau est dfini en utilisant les symboles [ et ] aprs le nom de la variable et
en faisant figurer le nombre dlments dsirs entre ces crochets; par exemple :
short tableau_d_entier[5];
dfinit une variable nomme tableau_d_entier qui est un tableau de 5 entiers de type
short. Les lments du tableau sont numrots de 0 (taille du tableau - 1); par exemple
nous pouvons raliser :
short tableau_d_entier[5];
tableau_d_entier[0] = 1;
tableau_d_entier[1] = 3;
tableau_d_entier[2] = 5;
tableau_d_entier[3] = 3;
tableau_d_entier[4] = 1;
Notez que nous pouvons dfinir les valeurs des lments du tableau lors de sa
dclaration, pour cela nous placerons les diffrentes valeurs entre accolades en les
sparant par des virgules; la dfinition suivante est identique au tableau prcdent :
short tableau_d_entier[5] = {1, 3, 5, 3, 1};
Nous pouvons galement dfinir des tableaux multi-dimensions en rptant la
spcification de taille faites avec les crochets, par exemple voici une matrice 2*2 :
float matrice[2][2];
matrice[0][0] = 1.0;
matrice[0][1] = 2.0;matrice[1][0] = 3.0;
matrice[1][1] = 4.0;
cette variable reprsente en quelque sorte la matrice :10 2 0
3 0 4 0
. .
. .
Notez quici aussi nous pouvons dfinir les valeurs des lments lors de la dclaration,
nous imbriquerons simplement des accolades pour dfinir chacune des dimensions du
tableau; ainsi la dfinition suivante est identique la matrice prcdente :
short matrice[2][2] = {{1.0, 2.0}, {3.0, 4.0}};
Il existe une forte similitude en C/C++ entre un type tableau et le type pointeur sur ce
mme type. Ainsi tant dfini le tableau_d_entier ci -dessus nous pouvons raliser :
-
7/27/2019 Programmation en Langage c c++ - 107 Pages
24/107
Sylvain Ferey (sferey@compuserve.com) 24
Forum des Programmeurs Francophones
short* ptr_entier = tableau_d_entier;
ou encore, c est identique :
short* ptr_entier = &tableau_d_entier[0];
En effet une variable tableau contient ladresse du premier lment de ce tableau.
-
7/27/2019 Programmation en Langage c c++ - 107 Pages
25/107
Sylvain Ferey (sferey@compuserve.com) 25
Forum des Programmeurs Francophones
Les tableaux dynamiques
Un tableau dynamique est un tableau dont la taille nest pas fige dans le source.
La remarque prcdente concernant la similitude entre une variable tableau et un
pointeur sur un type quivalent nous permet de dclarer aisment un tel tableau de
taille inconnue, nous utiliserons simplement un pointeur et stockerons ladresse de cetableau dans la variable pointeur.
Pour illustrer cela, nous devons savoir que le fichier den-tte (ou header) stdlib.h
dclare la fonction malloc() avec le prototype (lAPI) suivant :
void* malloc(size_t size);
cela signifie quelle attend un paramtre de type size_t (qui est galement dfini dans
ce fichier stdlib.h comme lquivalent de unsigned long int) qui indique le nombre
doctets allouer et quelle renvoie un pointeur void*.
Nous connaissions le type void que signifie void* ? Littralement cest un pointeur sur
rien du tout, dans la pratique cest le contraire : cela dcrit un pointeur sur nimporte
quelle type de donne, un pointeur universel en quelque sorte.
Il est important de noter que le paramtre tail le transmis malloc() (la variable nomme
size dans le prototype) est une taille en octets. Ainsi si nous ne souhaitons pas un
tableau doctets - de char - nous devrons prciser le nombre dlments multipli par la
taille dun lment. Pour cela nous pouvons utiliser loprateur sizeof() - ce nest pas
une fonction car le rsultat est valu la compilation - qui fournit la taille du type ou
de la variable utilis comme paramtre. Par exemple, lexpression sizeof(short) est
remplace par la valeur 2 durant la phase de compilation sur machine Intel.
Enfin, pour stocker le rsultat (de type void*) de la fonction malloc() dans notre variable,
nous devons raliser une conversion explicite de void* vers le type qui nous intresse.
Voyons comment raliser tout cela :
Code 4 : Cration dun tableau de taille quelconque
#include /* pour la fonction printf() */
#include /* pour la fonction malloc() */
voidmain(){
short i; /* une variable utilise pour une boucle */
short taille; /* mmorise la taille du tableau */
long* tableau; /* pointeur pour stocker ladresse du tableau */
taille = 5; /* saisi par l'utilisateur dans un vrai code */
/* allocation (dynamique) de notre tableau */
tableau = (long*) malloc(taille * sizeof(long));
/* remplissage du tableau, on utilise les indices 0 (taille -1) */
for (i = 0; i < taille; i++)
tableau[i] = i;
/* affichage du contenu du tableau */
for (i = 0; i < taille; i++)
printf("%lu\n", tableau[i]);
/* destruction du tableau : libration de la mmoire rserve */
free(tableau);
-
7/27/2019 Programmation en Langage c c++ - 107 Pages
26/107
Sylvain Ferey (sferey@compuserve.com) 26
Forum des Programmeurs Francophones
}
Notez que tout bloc de mmoire allou avec malloc() doit tre libr par un appel free().
Le prototype de free() est void free(void* ptr); ici il nest pas besoin de convertir
explicitement notre tableau de type long* en void*. En effet, un type pointeur gnrique
peut recevoir nimporte quel pointeur puisque cette conversion perd de linformation.
-
7/27/2019 Programmation en Langage c c++ - 107 Pages
27/107
Sylvain Ferey (sferey@compuserve.com) 27
Forum des Programmeurs Francophones
Les tableaux de caractres
Dans notre premier programme nous avons utilis la fonction printf() avec une chane
de caractres; notez quen C/C++ il nexiste pas de type chane de caractres
quivalent au type String du Pascal; ce type est obtenu en utilisant un tableau de
caractres.
Pour dclarer une chane statique, nous utiliserons donc un tableau - dont la taille sera
ou non prcise. Si elle ne lest pas le compilateur rservera un tableau pour y stocker
toute la chane, si par contre une taille N est prcis le compilateur ne retiendra que
les N premiers caractres de cette chane; exemple :
char chaine1[] = "hello"; /* dclaration correcte */
char chaine2[5]= "bonjour"; /* correct mais chane2 contient "bonjo" */
Que font ces instructions ?
Lorsque nous dclarons char chaine1[] = "hello", le compilateur rserve dans une zone
mmoire (gnralement dans le segment de donnes) six octets et il y range notre
chane en y ajoutant un caractre ascii zro marquant la fin de cette chane :
h e l l o 0
ensuite il fixe la valeur de chaine1 avec ladresse du premier caractre de la chane.
Notez que la dclaration :
char* chaine1 = "hello";
est compltement quivalente la dfinition de chaine1 prcdente.
Except cet ajout automatique dun caractre ascii zro de terminaison de chanes, lestableaux de caractres sont semblables aux tableaux dautres types.
Nous pourrons par exemple crer des chanes dynamiquement en utilisant malloc();
nous devrons cependant dans ce cas tre vigilant ajouter nous mme le caractre zro
lors de la construction de nos chanes.
-
7/27/2019 Programmation en Langage c c++ - 107 Pages
28/107
Sylvain Ferey (sferey@compuserve.com) 28
Forum des Programmeurs Francophones
Les oprateurs
Les oprateurs sont nombreux en C et C++, ceci est d au fait que certaines oprations
ralises par des fonctions dans dautres langages sont faites ici par des oprateurs et
galement au fait que le C et C++ permettent des formes dcritures doprations
impossibles dans dautres langages.
Les oprateurs mathmatiques
les oprateurs disponibles sont :
Oprateur Syntaxe Description
+ a + b calcule la somme de a et b
- a - b calcule la diffrence de a moins b
* a * b calcule la multiplication de a par b
/ a / b calcule la division de a par b
% a % b calcule le reste de la division entire de a par b
- - a value loppos de a
Notez que le rsultat dune opration numrique dpend du type de la variable rsultat,
en effet si ce nombre dpasse lintervalle de dfinition du type de la variable rsultat il
sera tronqu, exemple:
unsigned short a = 160, b = 500;
unsigned shortc = a * b;
printf("%hu\n", c); /* affiche 14464 soit 80000 - 65536 */
cette opration aurait d tre code :
unsigned short a = 160, b = 500;
unsigned long c = a * b;
printf("%u\n", c); /* affiche 80000 */
De plus lutilisation de nombres signs ou non signs peut galement produire des
rsultats diffrents, par exemple :
signed short a = 80, b = 500;
signed short c = a * b;
unsigned short d = a * b;
printf("%hd\n", c); /* affiche -25536 */
printf("%hu\n", d); /* affiche 40000 */
Dans cet exemple les variables c et d contiennent en fait exactement la mme valeur,
cest linterprtation que lon en fait qui provoque la diffrence des rsultats.
Enfin, le rsultats dpend du type des variables oprandes, ainsi le code :
short a = 80, b = 500;
float c = b / a;
printf("%g\n", c); /* affiche 6 au lieu de 6.25 */
-
7/27/2019 Programmation en Langage c c++ - 107 Pages
29/107
Sylvain Ferey (sferey@compuserve.com) 29
Forum des Programmeurs Francophones
naffiche pas le (vrai) rsultat de la division (non entire) de b par a; en effet a et b tant
entiers, une division entire est ralise.
-
7/27/2019 Programmation en Langage c c++ - 107 Pages
30/107
Sylvain Ferey (sferey@compuserve.com) 30
Forum des Programmeurs Francophones
Pour obtenir le rsultat correct il faut, soit introduire un nombre flottant dans les
arguments de la division, exemple :
short a = 80, b = 500;
float c = 1.0 * b / a;
printf("%g\n", c); /* affiche 6.25 */
soit retyper une des variables signed short en float, ce changement de type est ralis
en indiquant avant la variable altrer un nom de type entre parenthses :
short a = 80, b = 500;
float c = (float) b / a;
printf("%g\n", c); /* affiche 6.25 */
Les oprateurs logiques et relationnels
Les oprateurs suivant produisent tous un rsultat logique vrai (gnralement cod 1)
ou faux (cod 0).
Oprateur Syntaxe Description
== a == b value a gal b
!= a != b value a diffrent de b
&& a && b effectue un ET logique entre a et b
|| a || b effectue un OU logique entre a et b
! !a value la ngation logique de a
> a > b value a plus grand que b
>= a >= b value a plus grand ou gal b
=, b && c < d)
est quivalent :
( (a > b) && (c < d) )
De plus tous les oprateurs ont une priorit infrieure aux oprateurs mathmatiques,
ainsi :
(a < b - 1 && c % d)
est quivalent, puisque quun test logique est vrai pour toutes valeurs diffrentes de
zro, :
( ( a < (b - 1) ) && ((c % d) != 0) )
-
7/27/2019 Programmation en Langage c c++ - 107 Pages
31/107
Sylvain Ferey (sferey@compuserve.com) 31
Forum des Programmeurs Francophones
Loprateur unaire de ngation logique ! appliqu une valeur logique vrai ou faux
renvoie son contraire; appliqu une valeur numrique ou une adresse non nulle il
renvoie 0, enfin appliqu un oprande nul il renvoie 1; cet oprateur est couramment
utilis dans des tests :
long* a_ptr;
....a_ptr = (long*) malloc( 10 * sizeof(long) );
if (!a_ptr) {
/* lallocation a choue */
/* a_ptr est un pointeur nul */
}
short c;
....
if (!c){ /* quivalent : if (c == 0) */
....
}
Les oprateurs dincrmentation et dcrmentation
Loprateur ++ est loprateur dincrmentation: il ajoute 1 la variable sur lequel il
est appliqu. L'oprateur -- est loprateur de dcrmentation: il diminue de 1 la valeur
de la variable sur lequel il est appliqu.
Ces deux oprateurs produisent deux rsultats diffrents selon quils sont placs
gauche ou droite dune expression.
Placs gauche, ils agissent avant que la variable ne soit utilise dans linstruction qui
la contient; placs droite, ils agiront aprs que la variable ait t utilise.
Illustrons ceci :
short a = 5; /* dclare a avec la valeur 5 */
a++; /* fixe la valeur de a 6 */
short b = a++; /* fixe b a soit 6 */
/* PUIS incrmente a (a gal 7) */
short c = ++a; /* incrmente a (soit 8) */
/* PUIS affecte c (c gal 8) */
La position de loprateur (avant ou aprs loprande) induit donc des effets de bord (ou
effets rebond), ces effets peuvent tre trs sensibles et produiront un rsultat
imprvisible lorsque loprande apparat plusieurs fois dans lexpression; par exemple
linstruction suivante cherche remplir llment dindice i dun tableau avec cette
valeur de i :
short a[10]; /* un tableau de 10 entiers courts */
....
short i = 3;
a[ i ] = i++; /* qu'avons-nous ralis ??? */
aprs cette dernire instruction, i vaut 4 mais a ton fix a[ 3 ] ou a[ 4 ] ?
En fait cela dpend du compilateur et la seule rponse certaine est quil ne faut pasabuser des oprateurs ou pour le moins quune telle expression ne doit jamais tre
code.
-
7/27/2019 Programmation en Langage c c++ - 107 Pages
32/107
Sylvain Ferey (sferey@compuserve.com) 32
Forum des Programmeurs Francophones
Les oprateurs binaires
Ces oprateurs oprent sur la reprsentation binaire des nombres, ils ne peuvent donc
tre utiliss quavec des oprandes de type entiers.
Oprateur Syntaxe Description
& a & b effectue un ET bit bit
| a | b effectue un OU inclusif bit bit
^ a ^ b effectue un OU exclusif bit bit (appel aussi XOR)
a >> b effectue un dcalage droite de b bits sur le nombre a
~ ~a effectue un complment un (ngation binaire)
Les oprateurs de dcalage de bits seront utiliss avec prudence sur les types signs, en
effet lors dun dcalage droite les bits dcals seront remplis par des zros pour un
oprande non sign alors quun nombre sign sera complt de bits de signe (dcalage
arithmtique) ou par des zros (dcalage logique) en fonction de la machine utilise et /
ou du compilateur.
Rappel pour les personnes non rompues aux oprations binaires par une longue
pratique dassembleur:
un dcalage de bits gauche revient multiplier le nombre par une puissance de 2;
formellement a
-
7/27/2019 Programmation en Langage c c++ - 107 Pages
33/107
Sylvain Ferey (sferey@compuserve.com) 33
Forum des Programmeurs Francophones
Les oprateurs contracts
La plupart des oprations de la forme a = a oprateur b peuvent tre crites de manire
plus concise sous la forme a oprateur= b.
Ainsi:
a = a + b peut scrire a += b
a = a - 5 peut scrire a += 5
a = a * (b + 2) peut scrire a *= b + 2
a = a & 0x0F peut scrire a &= 0x0F
Remarque : il nexiste pas de forme contracte pour les oprateurs , ni,
videmment, pour les oprateurs unaires.
Les piges viter
Lors de votre apprentissage du langage C et C++ vous risquez de rencontrer des bugs
(incomprhensibles) ds des inversions entre diffrents oprateurs ressemblants.
Le premier pige viter, surtout si vous avez lexprience du Pascal, est la confusion
entre les oprateurs de tests (==) et daffectation (=), ainsi si vous crivez
a == 5;
au lieu de
a = 5;
le compilateur ne dtectera aucune erreur (sauf pour une expression comme short a ==
5;) et votre initialisation se rsumera un test (dont le rsultat est ignor).
Cette erreur est rarement commise, par contre linverse peut se produire, par exemplelors dun test :
if (a = 2) ... /* possible erreur de codage */
ici, non seulement le test sera toujours vrifi pour des valeurs diffrentes de zro, mais
en plus vous altrez le contenu de la variable; certains compilateurs mettent un
avertissement (affectation non dsire possible) pour ce type dcriture, dautres ne
vous diront rien.
Une solution pour contourner ce problme est dcrire, quand cela est possible, la
constante gauche du signe, ainsi :
if (2 = a) ... /* possible erreur de codage MAIS erreur de syntaxe */
provoquera toujours une erreur de compilation; cependant vous comparerez souvent
deux variables entre elles et dans ce cas cette astuce est inuti lisable; dans dautres cas
vous voulez prcisment raliser cette affectation et tester si la valeur transmise est
non nulle, cest le cas notamment lorsque vous stockez le rsultat dune fonction
retournant un code derreur, on crirait alors :
if ( err = maFonction() ) ...
ceci est valide et pour le coup on sera peut tre agac par les avertissement mis par le
compilateur, la meilleure faon dcrire une telle instruction serait :
if ( ( err = maFonction() ) == noErr ) ...
/* o noErr est une constante */
-
7/27/2019 Programmation en Langage c c++ - 107 Pages
34/107
Sylvain Ferey (sferey@compuserve.com) 34
Forum des Programmeurs Francophones
Lautre erreur souvent commise et linversion entre les oprateurs ET et OU logiques
versus binaires, ainsi:
short a = 5, b = 3;
if (a & 4 && b & 1) ...
est valu comme if ( 4 et 1 ) soit if ( vrai et vrai ), donc le test est vrifi. Par
contre :
short a = 5, b = 3;
if (a && 4 & b && 1) ...
est valu comme if ( 5 et (4 et binaire b) et 1 ) soit if ( 5 et 0 et 1), donc le test
nest pas vrifi.
-
7/27/2019 Programmation en Langage c c++ - 107 Pages
35/107
Sylvain Ferey (sferey@compuserve.com) 35
Forum des Programmeurs Francophones
Les instructions de tests
Linstruction if
Linstruction de test if ... else ... sert adapter un traitement toutes sortes de
conditions pouvant se ramener une expression vrai ou faux; notez que les mots cls
if et else doivent tre saisis en minuscule, comme tous les mots cls.
La syntaxe de linstruction if est :
if ( condition )
instruction ;
else
instruction ;
Remarque :
?? la condition test est toujours place entre parenthses.
?? la clause else et le bloc dinstruction li sont optionnels.
?? toute instruction se termine par un point virgule, y compris celle prcdant
linstruction else (contrairement la syntaxe du Pascal).
Nous supposons dans les exemples suivants que A, B et C dsignent des valeurs
boolennes. Voici un premier exemple de test simple :
if( A )
printf("A est vrai\n");
else
printf("A est faux\n");
Les blocs dinstructions excuts si le test est vrifi ou non peuvent tre constitus de
plusieurs instructions, nous utiliserons alors des accolades pour dlimiter ces blocs;
exemple :
if( A ) {
printf("A\n");
printf("est vrai\n");
}
else {
printf("A\n");
printf("est faux\n");
}
Souvent nous aurons dterminer le traitement raliser parmi plus de deux choix,
pour cela nous pouvons enchaner les tests if... else; exemple :
if( A )
printf("A est vrai\n");
else if ( B )
printf("B est vrai\n");
else
printf("A et B sont faux\n");
Lorsque nous enchanons plusieurs tests, il est important dtre vigilant sur la porte de
la clause else, considrons par exemple le bloc suivant :
-
7/27/2019 Programmation en Langage c c++ - 107 Pages
36/107
-
7/27/2019 Programmation en Langage c c++ - 107 Pages
37/107
-
7/27/2019 Programmation en Langage c c++ - 107 Pages
38/107
-
7/27/2019 Programmation en Langage c c++ - 107 Pages
39/107
Sylvain Ferey (sferey@compuserve.com) 39
Forum des Programmeurs Francophones
est quivalent :
short n;
.......
if( n != 0 )
printf("n est non nul\n");
else
printf("n est nul\n");
Des conditions avec et et ou
La condition test peut galement tre constitue de plusieurs conditions associes par
des critres et logique et ou logique.
Loprateur et logique scrit &&; loprateur ou logique scrit || ([Alt Gr] + 6);
exemple :
if( A && B )
printf("A et B sont vrais\n");
else if ( A || C )
printf("A ou C ou les deux sont vrais\n");
else
printf("A et C sont faux, B est peut tre vrai\n");
Loprateur ternaire ?:
On parle doprateur ternaire car celui-ci ncessite trois arguments, contrairement
aux oprateurs binaires qui prennent deux arguments (exemple loprateur de test ==,
on crit: arg1 == arg2) et aux oprateurs unaires qui nutilisent quun argument(exemple loprateur de ngation -, on crit: -arg).
Cet oprateur scrit: (condition) ? (instruction_1) : (instruction_2)
si la condition est vrifie le bloc instruction_1 est excut, sinon cest le bloc
instruction_2 qui lest.
Cet oprateur se prte bien aux affectations conditionnelles, par exemple nous
voudrions crire :
short choix;
if( A )choix = 1;
else
choix = 2;
ce code peut tre crit grce l oprateur ? : :
short choix = ( A ) ? 1 : 2;
Pour des raisons de lisibilit, on vitera son emploi dans des blocs de codes trop
compliqus. Retenez cependant que partout o nous utilisons une squence :
if( condition ) {
expression 1}
else {
-
7/27/2019 Programmation en Langage c c++ - 107 Pages
40/107
Sylvain Ferey (sferey@compuserve.com) 40
Forum des Programmeurs Francophones
expression 2
}
nous pouvons crire :
( condition ) ? { expression 1} : { expression 2}
-
7/27/2019 Programmation en Langage c c++ - 107 Pages
41/107
Sylvain Ferey (sferey@compuserve.com) 41
Forum des Programmeurs Francophones
Linstruction switch
Imaginons que nous souhaitons crire un bloc de tests portant de nombreuses
conditions, avec des critres ou logique et des tests imbriqus, par exemple :
short X;
...
if( X == 1 )
[instruction A];else if( X == 2 || X == 3 )
[instruction B];else if( X == 4 || X == 5) {
[instruction C];
if( X == 4 )
[instruction D];
}
else
[instruction E];
pour simplifier lcriture de tel bloc nous utiliserons linstruction switch( ... ) { ... }
associe plusieurs tiquettes case.
Nous utilisons comme argument de la clause switch lexpression dont nous aurions
teste la valeur; chaque valeur-test fait lobjet dune tiquette case suivie dun bloc
dinstructions et du mot cl break ds que le traitement raliser pour cette valeur-
test est effectu; enfin ltiquette default permet de grer tous les cas nayant pas t
traits.
Cela conduit :
short X;
...
switch( X ) {
case 1:
[instruction A];
break;
case 2:
case 3:
[instruction B];
break;
case 4:
[instruction C];
/* et continue avec l'instruction suivante */
case 5:
[instruction D];
break;
default:
[instruction E];
}
/* linstruction break nous mne ici */
Explications :
?? notez la prsence dun : (deux points) aprs la valeur des tiquettes case
?? ltiquette case 1: intercepte le cas o X est gal la valeur 1, le bloc [instruction A]
est alors excut puis linstruction break nous fait sortir du bloc switch. Cette
-
7/27/2019 Programmation en Langage c c++ - 107 Pages
42/107
Sylvain Ferey (sferey@compuserve.com) 42
Forum des Programmeurs Francophones
instruction break est indispensable, sans elle lexcution continuerait linairement
avec le bloc [instruction B].
?? ltiquette case 2: atteinte si X est gal 2 ne ralise aucune opration si ce nest
de poursuivre avec les instructions suivantes.
?? ltiquette case 3: est atteinte si X est gal 3 mais galement pour X gal 2
puisqu ltiquette prcdente nous navons pas effectu de break.
?? ltiquette case 4: provoque lexcution de l [instruction C]; nous ne faisons pas
suivre ce bloc dinstruction du mot cl break, lexcution se poursuit donc avec le bloc
[instruction D].
?? ltiquette case 5: est atteinte directement si X est gal 5 et par poursuite du
traitement si X tait gal 4; nous ralisons lexcution de l [instruction D] et nous
quittons le bloc switch.
?? enfin, tous les cas non traits (cest dire dans tous les cas o X est plus petit que 1
ou plus grand que 5) nous effectuons le bloc [instruction E].
Remarques :
?? ltiquette default est optionnelle.
?? une tiquette ne peut pas dfinir un intervalle de valeur, par exemple case 1..3: est
interdit; on crira la place plusieurs case comme pour les valeurs 2 et 3 dans
lexemple ci -dessus.
?? la valeur dune tiquette doit pouvoir tre value au moment de la compilation et
tre une valeur entire. Cest donc une valeur immdiate (comme une constante),
une opration sur des constantes (exemple: maConstante + 2), mais cela ne peut
pas tre le rsultat dune fonction ou tout autre expression value lexcutionuniquement.
?? les valeurs numriques des tiquettes nexigent ni dtre ordonnes (de la plus petite
valeur la plus grande) ni de former une srie discrte (1 puis 2 puis 3 ...).
-
7/27/2019 Programmation en Langage c c++ - 107 Pages
43/107
Sylvain Ferey (sferey@compuserve.com) 43
Forum des Programmeurs Francophones
Les instructions de boucles
Linstruction while
Linstruction de boucle while permet de raliser un traitement tant quune condition
boolenne est vraie.
La syntaxe de linstruction while est :
while( condition )
instruction ;
Remarque : la condition test est toujours place entre parenthses.
Si le bloc instruction est compos de plusieurs instructions, on placera ces instructions
entre les symboles de dbut et de fin de bloc: { et } soit :
while( condition ) {
instruction 1;instruction 2;
...
}
Exemple de boucle :
Code 5 : Boucle while(..) { ... }
#include
/* Saisie d'un nombre avec cho de ce nombre sur la console */
voidmain() {
short nombre = 1;while( nombre != 0 ){
printf("Tapez un nombre (0 pour sortir) : ");
scanf("%hd", &nombre);
printf("Votre nombre est %hd\n", nombre);
}
}
Le contenu de la boucle (affichage du message, saisie du nombre et raffichage du
nombre) est rpt tant que lutilisateur ne rentre pas la valeur zro.
Linstruction break
Linstruction de sortie de boucle break permet de quitter la boucle en cours. Ceci peut
tre utile si le traitement est irralisable ou si une erreur se produit dans la boucle.
Notez cependant que linstruction break quitte la boucle immdiatement parente; mais
en cas de boucle imbrique il reste dans la boucle prcdente.
Rcrivons le code prcdent pour limiter le traitement des nombres infrieurs 100 :
Code 6 : Boucle while(..) { ... } avec sortie par break
#include
voidmain() {
short nombre = 1;
while( nombre != 0 ){
printf("Tapez un nombre (0 pour sortir) : ");
-
7/27/2019 Programmation en Langage c c++ - 107 Pages
44/107
Sylvain Ferey (sferey@compuserve.com) 44
Forum des Programmeurs Francophones
scanf("%hd", &nombre);
if (nombre > 100)
break;
printf("Votre nombre est %hd\n", nombre);
}
}
-
7/27/2019 Programmation en Langage c c++ - 107 Pages
45/107
Sylvain Ferey (sferey@compuserve.com) 45
Forum des Programmeurs Francophones
Bien sr, nous aurions pu crire while ( nombre != 0 && nombre
-
7/27/2019 Programmation en Langage c c++ - 107 Pages
46/107
Sylvain Ferey (sferey@compuserve.com) 46
Forum des Programmeurs Francophones
ces boucles (avec contrle la fin) sont moins utilises, cependant il existera toujours
un problme pour lequel le meilleur algorithme utilisera cette forme de boucle.
-
7/27/2019 Programmation en Langage c c++ - 107 Pages
47/107
Sylvain Ferey (sferey@compuserve.com) 47
Forum des Programmeurs Francophones
Linstruction for
Linstruction de boucle for est peut tre la plus souple du langage C, on dit couramment
que nimporte quel programme C peut se ramener une boucle for; la syntaxe de
linstruction for est :
for ( initialisation ; test ; incrmentation )
instruction ;
Au nouveau, si plusieurs instructions doivent tre excutes chaque itration, on
crira :
for ( initialisation ; test ; incrmentation ) {
instruction 1;
instruction 2;
...
}
Les trois expressions dinitialisation, de tests et dincrmentation sont facultatives,
ainsi le bloc :
for ( ; ; ){}
est un bloc dinstruction valide, vide et rpt linfini.
Lexpression dinitialisation
La premire instruction sert initialiser des variables, vous pouvez aussi dfinir une
variable lors de cette initialisation (en C++ et sous certaines conditions en C), par
exemple une boucle contrle par une variable compteur commencerait par :
for ( short compteur = 0 ; . . .
Remarque : dans le cas o la variable est dfinie dans linstruction for, celle-ci nest
plus visible ds que lon sort de la boucle (son utilisation provoquera une erreur signale
par le compilateur). De plus les dernires normes du langage C++ recommandent ou
imposent lemploi dune variable locale comme variable de contrle de linstruction for et
la visibilit de cette variable est rduite cette boucle; ainsi dans :
for ( short compteur = 0 ; . . .) {
quelque chose;
}
for ( short compteur = 0 ; . . .) {
autre chose
}
lidentificateur compteur dcrit bien deux variables diffrentes, chacune ntant
utilisable que dans son instruction for; cependant encore de nombreux compilateurs
ignorent cette norme et signaleraient, par un avertissement ou une erreur, que
lidentificateur compteur est dj dclar lors de la compilation de la seconde boucle.
Lexpression de test
La condition de test est vrifie au dbut de lexcution du bloc, comme ctait le cas
pour linstruction while, ainsi si notre boucle commence par :
for ( short compteur = 0 ; compteur < 0 ; . . .
-
7/27/2019 Programmation en Langage c c++ - 107 Pages
48/107
Sylvain Ferey (sferey@compuserve.com) 48
Forum des Programmeurs Francophones
le corps de la boucle ne sera jamais excut car compteur (initialis zro) ne vrifie
pas la condition test (zro nest pas strictement infrieur zro).
De plus le test peut tre complexe et mettre en jeu des oprateurs logiques, par exemple
nous pouvons dfinir :
for ( short compteur = 0 ; compteur < ValeurMax && variableLogique ; . .
-
7/27/2019 Programmation en Langage c c++ - 107 Pages
49/107
-
7/27/2019 Programmation en Langage c c++ - 107 Pages
50/107
Sylvain Ferey (sferey@compuserve.com) 50
Forum des Programmeurs Francophones
De mme, lexpression dincrmentation incrmente compteur (compteur++) et, selon
le rsultat du test nombre % 2 qui calcule nombre modulo 2 et donc retourne 0 si
nombre est pair et 1 sil est impair, incrmente pairs ou impairs.
-
7/27/2019 Programmation en Langage c c++ - 107 Pages
51/107
Sylvain Ferey (sferey@compuserve.com) 51
Forum des Programmeurs Francophones
Revenons notre exemple dorigine, avec une boucle for nous crivons :
void main() {
short nombre = 1
for( ; nombre != 0 ; ){
printf("Tapez votre nombre (0 pour sortir) : ");
scanf("%hd", &nombre);
printf("Votre nombre est %hd\n", nombre);}
}
ici nous navons aucune opration dinitialisation ou dincrmentation raliser, seule
lexpression de test est alors dfinie.
Pour illustrer la polyvalence de la boucle for, remarquons que lexpression :
for ( expression 1 ; .expression 2 ; expression 3 ) {
instructions;
...
}
est quivalente lexpression :
expression 1;
while ( expression 2 ) {
instructions;
...
expression 3;
}
Linstruction continue
Nous avons vu tout lheure que linstruction break quittait la boucle en cours
dexcution; si en fait nous souhaitions de pas appliquer un traitement pour certainesvaleurs mais autoriser la poursuite de la boucle, nous pouvons utiliser linstruction
continue pour forcer valuer litration suivante sans quitter la boucle (dans lexemple
prsent ici, nous pouvions certes utiliser un test), exemple :
Code 9 : Boucle for avec break et continue
#include
/* Saisie de 10 nombres maximum avec cho de ce nombre sur la console */
/* si le nombre saisi est suprieur 10, il nest pas affich */
/* si le nombre saisi est suprieur 100, la boucle est interrompue */
void main() {short compteur;
short nombre = 1;
for( compteur = 0; compteur < 10 ; compteur++ ){
printf("Tapez votre nombre (0 pour sortir) : ");
scanf("%hd", &nombre);
if (nombre > 100)
break; /* finit le programme pour une valeur > 100 */
if (nombre > 10)
continue; /* finit cette itration pour une valeur > 10 */
printf("Votre nombre est %hd\n", nombre);
/* linstruction "continue" nous mne ici, compteur++ va tre
excut, le test compteur < 10 sera valu et le cas chant
-
7/27/2019 Programmation en Langage c c++ - 107 Pages
52/107
Sylvain Ferey (sferey@compuserve.com) 52
Forum des Programmeurs Francophones
litration suivante sera excute. */
}
/* linstruction "break" nous mne ici */
}
-
7/27/2019 Programmation en Langage c c++ - 107 Pages
53/107
Sylvain Ferey (sferey@compuserve.com) 53
Forum des Programmeurs Francophones
Les fonctions
Les fonctions sont omniprsentes en C; elles prsentent le moyen de diviser des taches
complexes en oprations plus simples et, avec le temps, les bibliothques de fonctions
que vous aurez crites constitueront votre capital-codage qui vous permettra de
construire de nouveaux programmes sans passer votre temps tout reconstruire
chaque fois.
Pour grer efficacement vos bibliothques de fonctions, nous vous conseillons de
maintenir des fichiers pas trop volumineux o les fonctions sont regroupes par thme.
Pour construire une bibliothque, vous devrez crer deux fichiers:
1. Un fichier den-tte (avec lextension .h) sera utilis pour stocker les dclarations -
ou prototypes - des fonctions.
2. Un fichier de dfinition (ayant le mme nom mais utilisant lextension .c sil sagit
de C pur et .cpp sil sagit de C++) contiendra limplmentation de ces fonctions.
Cette organisation assurera, vos bibliothques, une compatibilit maximale avec le
plus grand nombre de compilateurs.
Dclaration
La dclaration gnrique dune fonction est :
type_resultat nom_de_fonction ( type_parametre [nom_parametre] );
1. le type_resultat est un type fondamental, un type utilisateur ou un type pointeur sur
lun de ces types. Sil sagit dun type utilisateur il doit tre connu - cest dire avoir
t dclar - au moment de la dfinition de la fonction. La valeur void prcise que la
fonction ne renvoie rien (cest alors une procdure au sens pascalien du terme); ce
type_resultat dfinit le type de la fonction.
2. le type des paramtres reus est quelconque mais doit galement tre connu au
moment de la dfinition; on ne peut pas transmettre void mais void* est valide et
dcrit un pointeur universel.
3. le nom des paramtres est facultatif dans la dclaration de la fonction : vous pouvez
vous contenter de fournir uniquement leur type. De plus le nom que vous utiliserez
votre dcrire ce paramtre dans la dfinition de la fonction (son codage) peut tre
diffrent du nom que vous utiliseriez ici. Une bonne rgle est de choisir un nom
dcrivant au mieux ce que reprsente ce paramtre.
Le fichier de dclaration que vous allez crer sera inclus dans tous les fichiers de
codages (les .c ou .cpp) qui auront besoin dappeler ces fonctions; pour viter quun
fichier ne soit inclus plusieurs fois - par suite dinclusion en cascade de fichiers
utilisant les mmes dfinitions - ce qui pourrait provoquer des erreurs de redfinition de
symboles, nous utilisons une dfinition de constantes dcrivant ce fichier.
Pour cela nous utiliserons #ifndef (if not defined) afin de tester si un symbole - une
directive - est dfini, #define pour dfinir un symbole et #endif pour finir le #ifndef.
Remarque: il existe aussi #ifdef pour tester lexistence dune directive.
-
7/27/2019 Programmation en Langage c c++ - 107 Pages
54/107
Sylvain Ferey (sferey@compuserve.com) 54
Forum des Programmeurs Francophones
Grce ces instructions nommes pragma, nous pourrons en quelque sorte signer
notre fichier de dfinition en dfinissant une constante dont lexistence ne dure que le
temps de la compilation dun fichier, lhabitude veut que cette signature soit le nom du
fichier en majuscules avec un double soulign au dbut et la fin de ce nom.
-
7/27/2019 Programmation en Langage c c++ - 107 Pages
55/107
-
7/27/2019 Programmation en Langage c c++ - 107 Pages
56/107
Sylvain Ferey (sferey@compuserve.com) 56
Forum des Programmeurs Francophones
Nous pouvons galement inclure dautres fichiers de dfinitions si cela est ncessaire.
-
7/27/2019 Programmation en Langage c c++ - 107 Pages
57/107
Sylvain Ferey (sferey@compuserve.com) 57
Forum des Programmeurs Francophones
Le fichier doit dfinir toutes les fonctions dclares, dans le cas contraire il demeurera
parfaitement compilable mais si un programme utilise ce fichier il risque de ne pas
pouvoir tre construit du fait du manque de nos fonctions; dans un tel cas, il est
prfrable de ne pas inclure les fonctions non encore codes dans le fichier dclaration;
elles y seront ajoutes lorsque leur codage sera ralis.
Voici notre fichier dfinition pour notre librairie gomtrique :
Code 11 : Fichier de dfinition : geometry.c
/* Dclaration de la bibliothque gomtrique */
#ifndef __GEOMETRY__
#include "geometry.h"
/* les fichiers utilisateurs sont prciss entre guillemets */
#endif
#include /* les fichiers de systme sont prciss entre symboles < et > */
/* Dfinition des fonctions non exportes */
/* calcul du carr d'un nombre */
inline float sqr(const float x)
/* inline signifie que la fonction ne sera pas rellement appele
mais que son code sera recopie l o la fonction est appele,
cela acclre le traitement pour des petites fonctions */
{
return ( x * x );
}
/* Dfinition des fonctions publiques */
float surface_cercle( const float rayon )
{
/* M_PI est dfini dans math.h */
return M_PI * sqr( rayon );
}
float surface_carre( const float cote )
{
return sqr( cote );
}
float surface_forme( const float taille, forme_t forme )
{
switch ( forme ){
case CERCLE:
return surface_cercle( taille );
case CARRE:
return surface_carre( taille );
default:
return 0.0;
}
}
Ces deux fichiers dfinissent notre bibliothque. Le fichier geometry.h sera inclus partout fichier ayant besoin de ses fonctions, tandis que geometry.c devra tre inclus dans
la liste des fichiers du projet. Cest dire prsent sur la ligne de commande lors de
-
7/27/2019 Programmation en Langage c c++ - 107 Pages
58/107
Sylvain Ferey (sferey@compuserve.com) 58
Forum des Programmeurs Francophones
lappel au compilateur GNU ou insr dans votre projet si vous utilisez un gestionnaire
de projets.
-
7/27/2019 Programmation en Langage c c++ - 107 Pages
59/107
Sylvain Ferey (sferey@compuserve.com) 59
Forum des Programmeurs Francophones
Librairie
Nous pouvons simplifier un peu cela en construisant une vritable librairie.
Pour cela, nous compilons (une fois pour toute - jusqu sa prochaine modification) le
fichier geometry.c en utilisant loption -c de GNU gcc afin de demander seulement la
compilation du fichier (et non la cration dun excutable) :
> gcc -c geometry.c -o geometry.o
ceci cr un fichier geometry.o; loption -o geometry utilise pour lancer gcc est
optionnelle selon lenvironnement; nous convertissons maintenant ce fichier binaire au
format objet en une librairie :
> ar -rc geometry.a geometry.o
Sur systme unix et Linux, vous devrez peut tre excuter en plus :
> ranlib geometry.a
Ceci a cr notre librairie, voyons comment lutiliser, pour cela nous crons un petit
programme - ce sera un programme et non plus une bibliothque car il contiendra une
fonction main - ce fichier doit inclure geometry.h et utiliser geometry.a durant sa
construction.
Voici le programme, enregistrez-le sous test-geo.c :
Code 12 : Utilisation de la librairie : geometry.a
/* Utilisation de la bibliothque gomtrique */
#include
#include "geometry.h"
voidmain()
{
float carre = surface_forme ( 10.0, CARRE );
float cercle = surface_forme ( 5.0, CERCLE );
float rapport= cercle / carre;
printf( "un cercle inscrit dans un carre "
"occupe %g %% de sa surface\n", rapport );
}
Notez que la diffrenciation selon la casse permet de dfinir une variable carre qui est
bien un symbole diffrent de la constante CARRE dfinie dans geometry.h.
Nous compilons ce programme en incluant notre librairie dans la liste des fichiers :
> gcc test-geo.c geometry.a -o test-geo.exe
Nous pouvons alors lancer ce programme et nous obtenons :
> un cercle inscrit dans un carre occupe 0.7854 % de sa surface
Notez que notre programme aurait pu appeler directement les fonctions surface_cercle
et surface_carre puisque celles-ci sont exportes par le fichier de dclaration. Par
contre la fonction sqr, implmente dans geometry.c, mais non dfinie dans len-tte
reste cache et ne peut tre utilise qu lintrieur de geometry.c.
-
7/27/2019 Programmation en Langage c c++ - 107 Pages
60/107
Sylvain Ferey (sferey@compuserve.com) 60
Forum des Programmeurs Francophones
La fonction main
La fonction principale main est obligatoire pour crer un programme. Elle doit tre
unique et ce nom (ainsi que la casse) est impos.
Code de retour
La valeur retourne par la fonction main est soit de type int soit de type void.
En fait main retourne toujours une valeur car le systme qui a lanc votre programme
attend cette valeur de compte rendu dexcution; si vous avez dclar void, la valeur
retourne est imprvisible ou dpend de votre compilateur.
Sous Dos vous pouvez tester la valeur retourne avec la variable Dos errorlevel, en
voici un exemple :
Code 13 : Valeur retourne par la fonction main
int main()
{return 1;
}
Enregistrez ce fichier sous testmain.c et compilez-le pour crer testmain.exe.
Nous utilisons ensuite ce programme dans un fichier batch :
Code 14 : Lecture du code retourn par la fonction main
@echo off
testmain
if errorlevel 2 goto option2
if errorlevel 1 goto option1
if errorlevel 0 goto option0
:option0
echo l'option 0 est atteinte
goto fin
:option1
echo l'option 1 est atteinte
goto fin
:option2
echo l'option 2 est atteinte
goto fin
:fin
Enregistrez ce fichier sous testIt.bat et lancez-le, nous obtenons :
> l'option 1 est atteinte
Cette fonctionnalit permet de faire des programmes de type menu ou de construire des
systmes de traitement qui excutent leurs tapes via plusieurs programmes spars.
On testera alors le code de sortie de chaque programme avant de lancer le suivant; la
valeur zro est gnralement utilise pour signifier une excution correcte.
Remarque: ce principe existe galement sur unix et Linux, reportez-vous la
documentation du shell utilis pour savoir comment utiliser ce code retour.
-
7/27/2019 Programmation en Langage c c++ - 107 Pages
61/107
Sylvain Ferey (sferey@compuserve.com) 61
Forum des Programmeurs Francophones
Paramtres reus
La fonction main accepte plusieurs interfaces (prototypes) permettant ou non de recevoir
top related