Beruflich Dokumente
Kultur Dokumente
Professeur : NAMEZ
Langage de Programmation
Structure C
Cours du Langage C
Professeur : NAMEZ
SOMMAIRE
Chapitre 1 :
NOTIONS DE BASE
Chapitre 2 :
18
24
LA STRUCTURE ALTERNATIVE
Chapitre 5 :
29
LA STRUCTURE REPETITIVE
Chapitre 6 :
32
LES TABLEAUX
Chapitre 7 :
40
47
LES POINTEURS
Chapitre 9 :
59
LES FONCTIONS
Cours du Langage C
Professeur : NAMEZ
Chapitre 1 :
NOTIONS DE BASE
1. Hello C !
Suivons la tradition et commenons la dcouverte de C par l'invitable programme 'hello world'. Ce
programme ne fait rien d'autre qu'imprimer les mots suivants sur l'cran:
Hello world
Comparons d'abord la dfinition du programme en C avec celle en langage algorithmique.
HELLO_WORLD en langage algorithmique
Algorithme HELLO_WORLD
Dbut
|
(* Notre premier programme en C *)
|
crire "hello, world"
Fin
HELLO_WORLD en C
#include <stdio.h>
|main()
|/* Notre premier programme en C */
|{
|
printf("hello, world\n");
|
return 0;
|}
Algorithme <NomProgramme>
<Dclarations>
Dbut
|
<Instructions>
Fin
Dfinition de la fonction main en C
|main()
|{
|
<dclarations> ;
|
<instructions> ;
|
return 0;
|}
Cours du Langage C
Professeur : NAMEZ
Rsultat de main
- En principe tout programme devrait retourner une valeur comme code d'erreur son environnement.
Par consquent, le type rsultat de main est toujours int. En gnral, le type de main n'est pas
dclar explicitement, puisque c'est le type par dfaut. Nous allons terminer nos programmes par
l'instruction :
return 0;
Qui indique l'environnement que le programme s'est termin avec succs, sans anomalies ou
erreurs fatales.
- Si nous utilisons des fonctions prdfinies (par exemple: printf), il faut faire prcder la dfinition de
main par les instructions #include correspondantes.
{0,1,2,...,9,A,B,...,Z,_,a,b,...,z}
* Le premier caractre doit tre une lettre (ou le symbole '_')
* C distingue les majuscules et les minuscules, ainsi :
'Nom_de_variable' est diffrent de 'nom_de_variable'
* La longueur des identificateurs n'est pas limite, mais C distingue 'seulement' les 31 premiers
caractres.
Remarques :
- Il est dconseill d'utiliser le symbole '_' comme premier caractre pour un identificateur, car il est
souvent employ pour dfinir les variables globales de l'environnement C.
Exemples :
Identificateurs corrects:
Identificateurs incorrects:
nom1
nom_2
_nom_3
Nom_de_variable
deuxieme_choix
mot_francais
1nom
nom.2
-nom-3
Nom de variable
deuxime_choix
mot_franais
Cours du Langage C
Professeur : NAMEZ
Chapitre 2 :
description
domaine min
domaine max
nombre d'octets
char
short
int
long
caractre
entier court
entier standard
entier long
-128
-32768
-32768
-2147483648
127
32767
32767
2147483647
1
2
2
4
- char : caractre
Cours du Langage C
Professeur : NAMEZ
Une variable du type char peut contenir une valeur entre -128 et 127 et elle peut subir les mmes
oprations que les variables du type short, int ou long.
- int : entier standard
Sur chaque machine, le type int est le type de base pour les calculs avec les entiers. Le codage des
variables du type int est donc dpendant de la machine. Sur les IBM-PC sous MS-DOS, une variable
du type int est code dans deux octets.
- short : entier court
Le type short est en gnral cod dans 2 octets. Comme une variable int occupe aussi 2 octets sur
notre systme, le type short devient seulement ncessaire, si on veut utiliser le mme programme sur
d'autres machines, sur lesquelles le type standard des entiers n'est pas forcment 2 octets.
Remarques
1. Les valeurs limites des diffrents types sont indiques dans le fichier header <limits.h>.
2. En principe, on peut dire que
<+|->
<mantisse>
<exposant>
<+|-> <mantisse> * 10
est le signe positif ou ngatif du nombre
est un dcimal positif avec un seul chiffre devant la virgule
est un entier relatif
Exemples
3.14159*100
4.3001*10321
1.25003*10-12
-1.5*103
En C, nous avons le choix entre trois types de rationnels: float, double et long double. Dans le
tableau ci-dessous, vous trouverez leurs caractristiques :
min et max
mantisse
dfinition
prcision
float
simple
double
double
long double suppl.
mantisse
6
15
19
domaine min
domaine max
nombre d'octets
3.4 * 10-38
3.4 * 1038
4
1.7 * 10-308 1.7 * 10308 8
3.4 * 10-4932 1.1 * 104932 10
Cours du Langage C
Professeur : NAMEZ
<Type> <NomVar1>,<NomVar2>,...,<NomVarN>;
Prenons quelques dclarations du langage descriptif,
entier
COMPTEUR,X,Y
rel
HAUTEUR,LARGEUR,MASSE_ATOMIQUE
caractre
TOUCHE
boolen
T_PRESSEE
Et traduisons-les en des dclarations du langage C :
int
compteur,X,Y;
float
hauteur,largeur;
double
masse_atomique;
char
touche;
int
t_pressee;
Langage algorithmique --> C
En gnral, nous avons le choix entre plusieurs types et nous devons trouver celui qui correspond le
mieux au domaine et aux valeurs traiter. Voici quelques rgles gnrales qui concernent la
traduction des dclarations de variables numriques du langage algorithmique en C :
- La syntaxe des dclarations en C ressemble celle du langage algorithmique. Remarquez quand
mme les points-virgules la fin des dclarations en C.
Entier : Nous avons le choix entre tous les types entiers (inclusivement char) dans leurs formes
signe. Si les nombres deviennent trop grands, il faut utiliser un type rationnel (p.ex: double)
Rel : Nous pouvons choisir entre les trois types rationnels en observant non seulement la grandeur
maximale de l'exposant, mais plus encore le nombre de chiffres significatifs de la mantisse.
Caractre : Toute variable du type char peut contenir un (seul) caractre. En C, il faut toujours tre
conscient que ce 'caractre' n'est autre chose qu'un nombre correspondant un code (ici: code
ASCII). Ce nombre peut tre intgr dans toute sorte d'oprations algbriques ou logiques ...
Chane : En C il n'existe pas de type spcial pour chanes de caractres. Les moyens de traiter les
chanes de caractres seront dcrits au chapitre 8.
Boolen : En C il n'existe pas de type spcial pour variables boolennes. Tous les types de variables
numriques peuvent tre utiliss pour exprimer des oprations logiques:
valeur logique faux
valeur logique vrai
<=>
<=>
Cours du Langage C
Professeur : NAMEZ
Si l'utilisation d'une variable boolenne est indispensable, le plus naturel sera d'utiliser une variable du
type int.
Les oprations logiques en C retournent toujours des rsultats du type int :
0 pour faux
1 pour vrai
base octale
base hexadcimale
reprs. binaire
100
255
65536
12
4040
0144
0377
0200000
014
07710
0X64
0xff
0X10000
0XC
0xFC8
1100100
11111111
10000000000000000
1100
111111001000
Cours du Langage C
123.4
-0.001
Professeur : NAMEZ
1.0
* en notation exponentielle, c.--d. l'aide d'un exposant spar du nombre dcimal par les
caractres 'e' ou 'E':
Exemples
1234e-1
-1E-3
0.01E2
L'ordinateur reconnat les constantes rationnelles au point dcimal ou au sparateur de l'exposant ('e'
ou 'E'). Par dfaut, les constantes rationnelles sont du type double.
\a
\b
\t
\n
\r
\0
sonnerie
curseur arrire
tabulation
nouvelle ligne
retour au dbut de ligne
NUL
\\
\?
\'
\"
\f
\v
trait oblique
point d'interrogation
apostrophe
guillemets
saut de page (imprimante)
tabulateur vertical
Le caractre NUL
La constante '\0' qui a la valeur numrique zro (ne pas confondre avec le caractre '0' !!) a une
signification spciale dans le traitement et la mmorisation des chanes de caractres: En C le
caractre '\0' dfinit la fin d'une chane de caractres.
int
MAX = 1023;
char
TAB = '\t';
float
X = 1.05e-4;
Cours du Langage C
Professeur : NAMEZ
En utilisant l'attribut const, nous pouvons indiquer que la valeur d'une variable ne change pas au
cours d'un programme:
const int
MAX = 767;
const double
e = 2.71828182845905;
const char
NEWLINE = '\n';
<NomVariable> <Expression>
Affectation en C
<NomVariable> = <Expression>;
Exemples d'affectations
- L'affectation avec des valeurs constantes
Langage algorithmique
LONG 141
PI 3.1415926
LONG = 141;
(const. entire)
PI = 3.1415926; (const. relle)
Type de la constante
VALEUR X1A
VALEUR = X1A;
AIRE = PI*pow(R,2);
AIRE PI*R2
CORRECT ('a'='a') CORRECT = ('a' == 'a');
Observations
* il n'existe pas de fonction standard en C pour calculer le carr d'une valeur ; on peut se rfrer la
y
fonction plus gnrale pow(x,y) qui calcule x
* le test d'galit en C se formule avec deux signes d'galit ==, l'affectation avec un seul = .
+
*
/
%
addition
soustraction
multiplication
division (entire et rationnelle!)
modulo (reste d'une div. entire)
10
Cours du Langage C
Professeur : NAMEZ
Oprateurs logiques
==
gal
!=
diffrent de
<, <=, >, >= plus petit que, ...
Oprations logiques
Les rsultats des oprations de comparaison et des oprateurs logiques sont du type int :
- la valeur 1 correspond la valeur boolenne vrai
- la valeur 0 correspond la valeur boolenne faux
Les oprateurs logiques considrent toute valeur diffrente de zro comme vrai et zro comme faux :
32 && 2.3
!65.34
0||!(32 > 12)
1
0
0
+=
-=
*=
/=
%=
ajouter
diminuer de
multiplier par
diviser par
modulo
Avantages
11
Cours du Langage C
Professeur : NAMEZ
La formulation avec un oprateur d'affectation est souvent plus prs de la logique humaine : Un
homme dirait <<Ajoute 2 I>> plutt que <<Ajoute 2 I et cris le rsultat dans I>>
Les oprateurs d'affectation peuvent aider le compilateur gnrer un code plus efficient parce que
expr1 n'est valu qu'une seule fois.
- Les oprateurs d'incrmentation et de dcrmentation
Les affectations les plus frquentes sont du type :
I = I + 1
et
I = I - 1
X
X
X
X
=
=
=
=
I++
I-++I
--I
Exemple
Supposons que la valeur de N est gale 5:
Incrm. postfixe
Incrm. prfixe
i=0;
i++;
X=pow(A,4);
printf(" Bonjour !\n");
12
Cours du Langage C
Professeur : NAMEZ
a=(5*x+10*y)*2;
valuation et rsultats
En C toutes les expressions sont values et retournent une valeur comme rsultat :
()
! ++ -* / %
+ < <= > >=
== !=
&&
||
= += -= *= /= %=
13
Cours du Langage C
10+20
==>
30
30+30
Professeur : NAMEZ
==>
60
60-40
==>
20
20+50
==>
70
70-60
==>
10
Exemple
Observez la priorit des oprateurs d'affectation :
X *= Y + 1
X *= Y + 1
<=>
n'quivaut PAS
X = X * (Y + 1)
X = X * Y + 1
exp(X)
log(X)
log10(X)
pow(X,Y)
EXPLICATION
fonction exponentielle
logarithme naturel
logarithme base 10
X exposant Y
LANG. ALGORITHMIQUE
eX
ln(X), X>0
log10(X), X>0
XY
14
Cours du Langage C
sqrt(X)
fabs(X)
floor(X)
ceil(X)
fmod(X,Y)
Professeur : NAMEZ
racine carre de X
valeur absolue de X
arrondir en moins
arrondir en plus
reste rationnel de X/Y (mme signe que X)
|X|
int(X)
int I = 8;
float X = 12.5;
double Y;
Y = I * X;
Pour pouvoir tre multipli avec X, la valeur de I est convertie en float (le type le plus large des deux).
Le rsultat de la multiplication est du type float, mais avant d'tre affect a Y, il est converti en
double. Nous obtenons comme rsultat :
Y = 100.00
- Appels de fonctions
Lors de l'appel d'une fonction, les paramtres sont automatiquement convertis dans les types dclars
dans la dfinition de la fonction.
Exemple
15
Cours du Langage C
Professeur : NAMEZ
int A = 200;
int RES;
RES = pow(A, 2);
A l'appel de la fonction pow, la valeur de A et la constante 2 sont converties en double, parce que
pow est dfinie pour des donnes de ce type. Le rsultat (type double) retourn par pow doit tre
converti en int avant d'tre affect RES.
- Rgles de conversion automatique
Conversions automatiques lors d'une opration avec,
(1) deux entiers:
D'abord, les types char et short sont convertis en int. Ensuite, l'ordinateur choisit le plus large des
deux types dans l'chelle suivante : int, long
(2) un entier et un rationnel:
Le type entier est converti dans le type du rationnel.
(3) deux rationnels:
L'ordinateur choisit le plus large des deux types selon l'chelle suivante : float, double, long double
(4) affectations et oprateurs d'affectation:
Lors d'une affectation, le rsultat est toujours converti dans le type de la destination. Si ce type est
plus faible, il peut y avoir une perte de prcision.
Exemple
Observons les conversions ncessaires lors d'une simple division :
int X;
float A=12.48;
char B=4;
X=A/B;
B est converti en float (rgle 2). Le rsultat de la division est du type float (valeur 3.12) et sera
converti en int avant d'tre affect X (rgle 4), ce qui conduit au rsultat X=3.
Exemple
Dans cet exemple, nous divisons 3 par 4 trois reprises et nous observons que le rsultat ne dpend
pas seulement du type de la destination, mais aussi du type des oprandes.
char A=3;
int B=4;
float C=4;
float D,E;
16
Cours du Langage C
Professeur : NAMEZ
char F;
D = A/C;
E = A/B;
F = A/C;
* Pour le calcul de D, A est converti en float (rgle 2) et divis par C. Le rsultat (0.75) est affect D
qui est aussi du type float. On obtient donc: D=0.75
* Pour le calcul de E, A est converti en int (rgle 1) et divis par B. Le rsultat de la division (type int,
valeur 0) est converti en float (rgle 4). On obtient donc: E=0.000
* Pour le calcul de F, A est converti en float (rgle 2) et divis par C. Le rsultat (0.75) est retraduit en
char (rgle 4). On obtient donc: F=0
- Perte de prcision
Lorsque nous convertissons une valeur en un type qui n'est pas assez prcis ou pas assez grand, la
valeur est coupe sans arrondir et sans nous avertir ...
(<Type>) <Expression>
Exemple
Nous divisons deux variables du type entier. Pour avoir plus de prcision, nous voulons avoir un
rsultat de type rationnel. Pour ce faire, nous convertissons l'une des deux oprandes en float.
Automatiquement C convertira l'autre oprande en float et effectuera une division rationnelle :
char A=3;
int B=4;
float C;
C = (float)A/B;
La valeur de A est explicitement convertie en float. La valeur de B est automatiquement convertie en
float (rgle 2). Le rsultat de la division (type rationnel, valeur 0.75) est affect C.
Rsultat : C=0.75
Attention !
Les contenus de A et de B restent inchangs; seulement les valeurs utilises dans les calculs sont
converties !
17
Cours du Langage C
Professeur : NAMEZ
Chapitre 3 :
printf("<format>",<Expr1>,<Expr2>, ... )
"<format>"
<Expr1>,...
format de reprsentation
variables et expressions dont les valeurs sont reprsenter
La partie "<format>" est en fait une chane de caractres qui peut contenir :
* du texte
* des squences d'chappement
* des spcificateurs de format
* Les spcificateurs de format indiquent la manire dont les valeurs des expressions <Expr1N>
sont imprimes.
* La partie "<format>" contient exactement un spcificateur de format pour chaque expression
<Expr1...N>.
* Les spcificateurs de format commencent toujours par le symbole % et se terminent par un ou deux
caractres qui indiquent le format d'impression.
* Les spcificateurs de format impliquent une conversion d'un nombre en chane de caractres. Ils
sont encore appels symboles de conversion.
Exemple 1
int A = 1234;
int B = 567;
printf("%i fois %i est %li\n", A, B, (long)A*B);
La suite d'instructions va afficher sur l'cran :
la partie format
18
Cours du Langage C
la variable
la variable
l'expression
er
Le 1
Le 2
Le 3
Professeur : NAMEZ
A
B
(long)A*B
==>1234
==> 567
==> 699678
Exemple 2
char B = 'A';
printf("Le caractre %c a le code %i !\n", B, B);
La suite d'instructions va afficher sur l'cran :
Le caractre A a le code 65 !
La valeur de B est donc affiche sous deux formats diffrents :
%c comme caractre
A
%i comme entier relatif 65
Spcificateurs de format pour printf
SYMBOLE
%d ou %i
%o
%x
%c
%f
%e
%s
TYPE
int
int
int
int
double
double
char*
IMPRESSION COMME
entier relatif
entier exprim en octal
entier exprim en hexadcimal
caractre
rationnel en notation dcimale
rationnel en notation scientifique
chane de caractres
19
Cours du Langage C
Professeur : NAMEZ
printf("%4d",
printf("%4d",
printf("%4d",
printf("%4u",
printf("%4X",
printf("%4x",
123);
1234);
12345);
0);
123);
123);
==>
==>
==>
==>
==>
==>
_123
1234
12345
___0
__7B
__7b
printf("%f", 100.123);
printf("%12f", 100.123);
printf("%.2f", 100.123);
printf("%5.0f", 100.123);
printf("%10.3f", 100.123);
printf("%.4f", 1.23456);
==>
==>
==>
==>
==>
==>
100.123000
__100.123000
100.12
__100
___100.123
1.2346
scanf("<format>",<AdrVar1>,<AdrVar2>, ...)
"<format>"
<AdrVar1>,...
:
:
* La fonction scanf reoit ses donnes partir du fichier d'entre standard stdin (par dfaut le clavier).
* La chane de format dtermine comment les donnes reues doivent tre interprtes.
* Les donnes reues correctement sont mmorises successivement aux adresses indiques par
<AdrVar1>,... .
20
Cours du Langage C
Professeur : NAMEZ
* L'adresse d'une variable est indique par le nom de la variable prcd du signe &.
Exemple
La suite d'instructions :
SYMBOLE
%d ou %i
%c
%s
%f ou %e
LECTURE D'UN
entier relatif
caractre
chane de caractres
rationnel en notation dcimale ou exponentielle (scientifique)
1. Le type long
Si nous voulons lire une donne du type long, nous devons utiliser les spcificateurs %ld, %li, %lu,
%lo, %lx. (Sinon, le nombre est simplement coup la taille de int).
2. Le type double
Si nous voulons lire une donne du type double, nous devons utiliser les spcificateurs %le ou %lf.
3. Le type long double
Si nous voulons lire une donne du type long double, nous devons utiliser les spcificateurs %Le ou
%Lf.
4. Les signes d'espacement
Lors de l'entre des donnes, une suite de signes d'espacement (espaces, tabulateurs, interlignes)
est value comme un seul espace. Dans la chane de format, les symboles \t, \n, \r ont le mme
effet qu'un simple espace.
Exemple
Pour la suite d'instructions
12 4 1980
ou
12
004
ou
1980
21
Cours du Langage C
Professeur : NAMEZ
12
4
1980
5. Formats 'spciaux'
Si la chane de format contient aussi d'autres caractres que des signes d'espacement, alors ces
symboles doivent tre introduits exactement dans l'ordre indiqu.
Exemple : La suite d'instructions
12/4/1980
12/04/01980
12 4 1980
12 /4 /1980
putchar('a');
Transfre le caractre a vers le fichier standard de sortie stdout. Les arguments de la fonction
putchar sont ou bien des caractres (c.--d. des nombres entiers entre 0 et 255).
Type de l'argument
Ainsi, les arguments de putchar sont par dfinition du type int et toutes les valeurs traites par
putchar (mme celles du type char) sont d'abord converties en int.
Exemples
char A = 225;
char B = '\a';
int C = '\a';
putchar('x');
putchar('?');
putchar('\n');
putchar(65);
putchar(A);
putchar(B);
putchar(C);
putchar(EOF);
/*
/*
/*
/*
/*
/*
/*
/*
/*
/*
afficher la lettre x
afficher le symbole ?
retour la ligne
afficher le symbole avec
le code 65 (ASCII: 'A')
afficher la lettre avec
le code 225 (ASCII: '')
beep sonore
beep sonore
marquer la fin du fichier
*/
*/
*/
*/
*/
*/
*/
*/
*/
*/
22
Cours du Langage C
Professeur : NAMEZ
Type du rsultat
Les valeurs retournes par getchar sont ou bien des caractres (0 - 255), le type rsultat de getchar
est int. En gnral, getchar est utilis dans une affectation :
int C;
C = getchar();
Remarque :
getchar lit les donnes de la zone tampon de stdin et fournit les donnes seulement aprs
confirmation par 'Enter'. La bibliothque <conio> contient une fonction du nom getch qui fournit
immdiatement le prochain caractre entr au clavier.
23
Cours du Langage C
Professeur : NAMEZ
Chapitre 4 :
LA STRUCTURE ALTERNATIVE
Les structures de contrle dfinissent la suite dans laquelle les instructions sont effectues.
Constatons dj que la particularit la plus importante des instructions de contrle en C est le fait que
les 'conditions' en C peuvent tre des expressions quelconques qui fournissent un rsultat numrique.
La valeur zro correspond la valeur logique faux et toute valeur diffrente de zro est considre
comme vrai.
1. if - else
if ( <expression> )
<bloc d'instructions 1>
else
<bloc d'instructions 2>
* Si l'<expression> fournit une valeur diffrente de zro, alors le <bloc d'instructions 1> est excut.
* Si l'<expression> fournit la valeur zro, alors le <bloc d'instructions 2> est excut.
La partie <expression> peut dsigner :
Une variable d'un type numrique,
Une expression fournissant un rsultat numrique.
La partie <bloc d'instructions> peut dsigner :
Un (vrai) bloc d'instructions compris entre accolades,
Une seule instruction termine par un point-virgule.
Exemple 1
if (a > b)
max = a;
else
max = b;
Exemple 2
if (EGAL)
printf("A est gal B\n");
else
printf("A est diffrent de B\n");
Exemple 3
24
Cours du Langage C
Professeur : NAMEZ
2. if sans else
La partie else est facultative. On peut donc utiliser if de la faon suivante :
if sans else
if ( <expression> )
<bloc d'instructions>
Attention !
Comme la partie else est optionnelle, les expressions contenant plusieurs structures if et if - else
peuvent mener des confusions.
Exemple
L'expression suivante peut tre interprte de deux faons :
if (N>0)
if (A>B)
MAX=A;
else
MAX=B;
if (N>0)
if (A>B)
MAX=A;
else
MAX=B;
if (N>0)
{
if (A>B)
MAX=A;
}
else
MAX=B;
25
Cours du Langage C
Professeur : NAMEZ
if ( <expr1> )
<bloc1>
else if (<expr2>)
<bloc2>
else if (<expr3>)
<bloc3>
else if (<exprN>)
<blocN>
else <blocN+1>
Les expressions <expr1> ... <exprN> sont values du haut vers le bas jusqu' ce que l'une d'elles
soit diffrente de zro. Le bloc d'instructions y li est alors excut et le traitement de la commande
est termin.
Exemple
#include <stdio.h>
main()
{
int A,B;
printf("Entrez deux nombres entiers :");
scanf("%i %i", &A, &B);
if (A > B)
printf("%i est plus grand que %i\n", A, B);
else if (A < B)
printf("%i est plus petit que %i\n", A, B);
else
printf("%i est gal %i\n", A, B);
return 0;
}
La dernire partie else traite le cas o aucune des conditions n'a t remplie. Elle est optionnelle,
mais elle peut tre utilise trs confortablement pour dtecter des erreurs.
Switch (expression) {
Case constante_1 :
<Bloc dinstructions_1> ;
Break ;
Case constante_2 :
<Bloc dinstructions_2> ;
26
Cours du Langage C
Professeur : NAMEZ
Break ;
Case constante_N :
<Bloc dinstructions_N> ;
Break ;
Default :
<Bloc dinstructions_N+1> ;
}
* Expression : expression entire quelconque.
* Constante_1 Constante_2 Constante_N : expressions constantes dun type entier quelconque
(le type char est accept car il sera converti en int).
* <Bloc dinstructions_1> <Bloc dinstructions_N> : squences dinstructions quelconques.
Ceci est quivalent :
if (expression==constante_1)
<Block dinstuctions_1> ;
else if (valeur==constante_2)
<Block dinstuctions_2> ;
else if (valeur==constante_N)
<Block dinstuctions_N> ;
else
<Block dinstuctions_N+1> ;
Attention !
Linstruction break sert interrompre le flux dexcution. Si on lomet, les instructions suivant les
case sont excutes en squence :
Switch (valeur) {
Case constante1 :
Instructions1 ;
Case constante2 :
Instructions2 ;
Default :
Instructions3 ;
}
Est quivalent :
if (valeur==constante1) {
instuctions1 ;
instuctions2 ;
instuctions3 ;
}
else if (valeur==constante2) {
instuctions2 ;
27
Cours du Langage C
Professeur : NAMEZ
instuctions3 ;
}
else
instuctions3 ;
if (A>B)
MAX=A;
else
MAX=B;
Peut tre remplace par :
MAX = (A > B) ? A : B;
Employs de faon irrflchis, les oprateurs conditionnels peuvent nuire la lisibilit d'un
programme, mais si on les utilise avec prcaution, ils fournissent des solutions trs lgantes :
Exemple
(N>0) ? N : F
Va toujours fournir un rsultat du type float, n'importe si N est plus grand ou plus petit que zro !
28
Cours du Langage C
Professeur : NAMEZ
Chapitre 5 :
LA STRUCTURE REPETITIVE
En C, nous disposons de trois structures qui nous permettent la dfinition de boucles conditionnelles:
1) la structure while
2) la structure do - while
3) la structure for
1. while
while ( <expression> )
<bloc d'instructions>
* Tant que l'<expression> fournit une valeur diffrente de zro, le <bloc d'instructions> est excut.
* Si l'<expression> fournit la valeur zro, l'excution continue avec l'instruction qui suit le bloc
d'instructions.
* Le <bloc d'instructions> est excut zro ou plusieurs fois.
La partie <bloc d'instructions> peut dsigner : Un (vrai) bloc d'instructions compris entre accolades ou
Une seule instruction termine par un point-virgule.
Exemple 1
int I;
/* Afficher les nombres de 0 9 */
I = 0;
while (I<10)
printf("%i \n", I++);
Exemple 3
29
Cours du Langage C
Professeur : NAMEZ
2. do - while
La structure do - while est semblable la structure while, avec la diffrence suivante :
* while value la condition avant d'excuter le bloc d'instructions,
* do - while value la condition aprs avoir excut le bloc d'instructions. Ainsi le bloc d'instructions
est excut au moins une fois.
La structure do - while en C
do
<bloc d'instructions>
while ( <expression> );
* Le <bloc d'instructions> est excut au moins une fois et aussi longtemps que l'<expression> fournit
une valeur diffrente de zro.
En pratique, la structure do - while n'est pas si frquente que while ; mais dans certains cas, elle
fournit une solution plus lgante. Une application typique de do - while est la saisie de donnes qui
doivent remplir une certaine condition : Le contrle de saisie
Exemple 1
float N;
do
{
printf("Introduisez un nombre entre 1 et 10 :");
scanf("%f", &N);
}
while (N<1 || N>10);
Exemple 2
int n, div;
printf("Entrez le nombre diviser : ");
scanf("%i", &n);
do
{
printf("Entrez le diviseur (diffrent de 0) : ");
scanf("%i", &div);
}
while (div==0);
printf("%i / %i = %f\n", n, div, (float)n/div);
Remarque
do - while est comparable la structure rpter du langage algorithmique (repeat until en Pascal) si
la condition finale est inverse logiquement.
3. for
30
Cours du Langage C
Professeur : NAMEZ
<expr1>;
while ( <expr2> )
{
<bloc d'instructions>
<expr3>;
}
<expr1> est value une fois avant le passage de la boucle. Elle est utilise pour initialiser les
donnes de la boucle.
<expr2> est value avant chaque passage de la boucle. Elle est utilise pour dcider si la boucle est
rpte ou non.
<expr3> est value la fin de chaque passage de la boucle. Elle est utilise pour rinitialiser les
donnes de la boucle.
Le plus souvent, for est utilis comme boucle de comptage :
int I;
for (I=0 ; I<=20 ; I++)
printf("Le carr de %d est %d \n", I, I*I);
En pratique, les parties <expr1> et <expr2> contiennent souvent plusieurs initialisations ou
rinitialisations, spares par des virgules.
Exemple 2
int n, S=0;
for (n=1 ; n<=100 ; n++)
S+=n;
printf("La somme des nombres de 1 100 est %d\n", S);
31
Cours du Langage C
Professeur : NAMEZ
Chapitre 5 :
LES TABLEAUX
1. Les tableaux une dimension
Un tableau (uni-dimensionnel) A est une variable structure forme d'un nombre entier N de variables
simples du mme type, qui sont appeles les composantes du tableau. Le nombre de composantes
N est alors la dimension du tableau.
<TypeSimple> <NomTableau>[<Dimension>];
Exemples
int A[25];
ou bien
float B[100]; ou bien
int C[10];
char D[30];
long A[25];
ou bien
double B[100]; ou bien
...
...
Mmorisation
En C, le nom d'un tableau est le reprsentant de l'adresse du premier lment du tableau. Les
adresses des autres composantes sont calcules (automatiquement) relativement cette adresse.
Exemple
long T[15];
C rservera N*M = 15*4 = 60 octets en mmoire.
32
Cours du Langage C
Professeur : NAMEZ
int A[5]
= {10, 20, 30, 40, 50};
float B[4] = {-1.05, 3.33, 87e-5, -12.3E4};
int C[10] = {1, 0, 0, 1, 1, 1, 0, 1, 0, 1};
Il faut videmment veiller ce que le nombre de valeurs dans la liste corresponde la dimension du
tableau. Si la liste ne contient pas assez de valeurs pour toutes les composantes, les composantes
restantes sont initialises par zro.
Rservation automatique
Si la dimension n'est pas indique explicitement lors de l'initialisation, alors l'ordinateur rserve
automatiquement le nombre d'octets ncessaires.
Exemples
33
Cours du Langage C
Professeur : NAMEZ
int A[5];
nous avons dfini un tableau A avec cinq composantes, auxquelles on peut accder par :
Attention !
Considrons un tableau T de dimension N
- l'accs au premier lment du tableau se fait par T[0]
- l'accs au dernier lment du tableau se fait par T[N-1]
main()
{
int A[10];
int I,N; /* Compteur et Nombre des elements du tableau */
printf(Donnez le nombre des elements du tableau : ) ;
scanf("%d ",&N);
/* Lecture */
for (I=0; I<N; I++)
{
printf(Donnez la composante %d : ,I+1);
scanf("%d", &A[I]);
}
/* Affichage */
for (I=0; I<N; I++)
printf("%d ", A[I]);
return 0;
}
Remarque
* Pour tre sr que les valeurs sont bien spares lors de l'affichage, il faut inclure au moins un
espace dans la chane de format. Autres possibilits:
34
Cours du Langage C
Professeur : NAMEZ
* Comme scanf a besoin des adresses des diffrentes composantes du tableau, il faut faire prcder
le terme A[I] par l'oprateur adresse '&'.
* La commande de lecture scanf doit tre informe du type exact des donnes lire. (Ici : %d ou %i
pour lire des valeurs du type int)
<TypeSimple> <NomTabl>[<DimLigne>][<DimCol>];
Exemples
int A[10][10];
ou bien long A[10][10];
ou bien ...
float B[2][20]; ou bien double B[2][20]; ou bien ...
int C[3][3];
char D[15][40];
Mmorisation
Comme pour les tableaux une dimension, le nom d'un tableau est le reprsentant de l'adresse du
premier lment du tableau (c.--d. l'adresse de la premire ligne du tableau). Les composantes
d'un tableau deux dimensions sont stockes ligne par ligne dans la mmoire.
Exemple
35
Cours du Langage C
Professeur : NAMEZ
double T[10][15];
C rservera L*C*M = 10*15*8 = 1200 octets en mmoire.
<NomTableau>[<NLigne>][<NColonne>]
Les lments d'un tableau de dimensions L et C se prsentent de la faon suivante :
A[0][0]
A[1][0]
A[2][0]
. . .
A[L-1][0]
A[0][1]
A[1][1]
A[2][1]
. . .
A[L-1][1]
A[0][2]
.
A[1][2]
.
A[2][2]
.
. . .
. .
A[L-1][2]
.
.
.
.
.
.
.
.
.
.
A[0][C-1]
A[1][C-1]
A[2][C-1]
. . .
A[L-1][C-1]
main()
{
int A[5][10];
int I,J;
/* Nombre de lignes et de colonnes du tableau*/
int L,C;
printf(Donnez le nombre de lignes du tableau : ) ;
scanf("%d ",&L);
printf(Donnez le nombre de colonnes du tableau : ) ;
scanf("%d ",&C);
/* Lecture */
/* Pour chaque ligne ... */
for (I=0; I<L; I++)
/* ... considrer chaque composante */
for (J=0; J<C; J++)
{
printf(Donnez lelement A[%d][%d]: ,I,J);
36
Cours du Langage C
Professeur : NAMEZ
scanf("%d", &A[I][J]);
}
/* Affichage */
/* Pour chaque ligne ... */
for (I=0; I<L; I++)
{
/* ... considrer chaque composante */
for (J=0; J<C; J++)
printf("%7d", A[I][J]);
/* Retour la ligne */
printf("\n");
}
return 0;
}
Remarques
* Pour obtenir des colonnes bien alignes lors de l'affichage, il est pratique d'indiquer la largeur
minimale de l'affichage dans la chane de format. Pour afficher des matrices du type int (valeur la plus
'longue': -32768), nous pouvons utiliser la chane de format "%7d" :
37
Cours du Langage C
Professeur : NAMEZ
Chapitre 6 :
1. Dclaration et mmorisation
Dclaration
est un caractre constant, qui a une valeur numrique : P.ex: 'x' a la valeur 120 dans le code
ASCII.
est un tableau de caractres qui contient deux caractres : la lettre 'x' et le caractre NUL: '\0'
38
Cours du Langage C
Professeur : NAMEZ
char A[6];
Nous avons dfini un tableau A avec six lments, auxquels on peut accder par :
car 'A'<'B'
car 'A'<'B'
car 'A'<'a'
39
Cours du Langage C
Professeur : NAMEZ
->
:hello, world:
puts est idale pour crire une chane constante ou le contenu d'une variable dans une ligne isole.
Syntaxe :
puts( <Chane> )
Effet :
puts crit la chane de caractres dsigne par <Chane> sur stdout et provoque
un retour la ligne. En pratique,
Exemple
char LIEU[25];
int JOUR, MOIS, ANNEE;
printf("Entrez lieu et date de naissance : \n");
scanf("%s %d %d %d", LIEU, &JOUR, &MOIS, &ANNEE);
Remarques importantes
- La fonction scanf a besoin des adresses de ses arguments : Comme le nom d'une chane de
caractres est le reprsentant de l'adresse du premier caractre de la chane, il ne doit pas tre
prcd de l'oprateur adresse '&' !
40
Cours du Langage C
Professeur : NAMEZ
- La fonction scanf avec plusieurs arguments prsuppose que l'utilisateur connaisse exactement le
nombre et l'ordre des donnes introduire! Ainsi, l'utilisation de scanf pour la lecture de chanes de
caractres est seulement conseille si on est forc de lire un nombre fix de mots en une fois.
gets est idal pour lire une ou plusieurs lignes de texte (p.ex. des phrases) termines par un retour
la ligne.
Syntaxe :
gets( <Chane> )
Effet :
gets lit une ligne de de caractres de stdin et la copie l'adresse indique par
<Chane>. Le retour la ligne final est remplac par le symbole de fin de chane '\0'.
Exemple
Remarques
- Comme le nom d'une chane de caractres reprsente une adresse fixe en mmoire, on ne peut pas
'affecter' une autre chane au nom d'un tableau:
Il faut bien copier la chane caractre par caractre ou utiliser la fonction strcpy :
strcpy(A, "Hello");
- La concatnation de chanes de caractres en C ne se fait pas par le symbole '+' comme en langage
algorithmique ou en Pascal. Il faut ou bien copier la deuxime chane caractre par caractre ou bien
utiliser la fonction strcat.
41
Cours du Langage C
Professeur : NAMEZ
- La fonction strcmp est dpendante du code de caractres et peut fournir diffrents rsultats sur
diffrentes machines.
char JOUR[7][9];
Initialisation
Lors de la dclaration il est possible d'initialiser toutes les composantes du tableau par des chanes de
caractres constantes :
Mmorisation
Les tableaux de chanes sont mmoriss ligne par ligne. La variable JOUR aura donc besoin de
7*9*1 = 63 octets en mmoire.
42
Cours du Langage C
Professeur : NAMEZ
Des expressions comme JOUR[I] reprsentent l'adresse du premier lment d'une chane de
caractres. N'essayez donc pas de 'modifier' une telle adresse par une affectation directe !
L'attribution d'une chane de caractres une composante d'un tableau de chanes se fait en gnral
l'aide de la fonction strcpy :
Exemple : La commande :
strcpy(JOUR[4], "Friday");
e
43
Cours du Langage C
Professeur : NAMEZ
Chapitre 8 :
LES POINTEURS
1. Adressage de variables
1.1. Adressage direct
Accs au contenu d'une variable par le nom de la variable.
Exemple
2. Les pointeurs
Dfinition
Un pointeur est une variable spciale qui peut contenir l'adresse d'une autre variable.
En C, chaque pointeur est limit un type de donnes. Il peut contenir l'adresse d'une variable simple
de ce type ou l'adresse d'une composante d'un tableau de ce type.
Si un pointeur P contient l'adresse d'une variable A, on dit que 'P pointe sur A'.
Remarque
Les pointeurs et les noms de variables ont le mme rle : Ils donnent accs un emplacement dans
la mmoire interne de l'ordinateur. Il faut quand mme bien faire la diffrence :
* Un pointeur est une variable qui peut 'pointer' sur diffrentes adresses.
* Le nom d'une variable reste toujours li la mme adresse.
44
Cours du Langage C
Professeur : NAMEZ
&<NomVariable>
fournit l'adresse de la variable <NomVariable>
Attention !
L'oprateur & peut seulement tre appliqu des objets qui se trouvent dans la mmoire interne, cd.
des variables et des tableaux. Il ne peut pas tre appliqu des constantes ou des expressions.
Reprsentation schmatique
Soit P un pointeur non initialis
Alors l'instruction
P = &A;
Affecte l'adresse de la variable A la variable P. En mmoire, A et P se prsentent comme dans le
graphique la fin du paragraphe 1.2. Dans notre reprsentation schmatique, nous pouvons illustrer
le fait que 'P pointe sur A' par une flche :
*<NomPointeur>
dsigne le contenu
<NomPointeur>
de
l'adresse
Exemple
45
rfrence
par
le
pointeur
Cours du Langage C
Professeur : NAMEZ
Soit A une variable contenant la valeur 10, B une variable contenant la valeur 50 et P un pointeur non
initialis :
P = &A;
B = *P;
*P = 20;
- P pointe sur A,
- le contenu de A (rfrenc par *P) est affect B,
- le contenu de A (rfrenc par *P) est mis 20.
<Type> *<NomPointeur>
dclare un pointeur <NomPointeur> qui peut recevoir des adresses de
variables du type <Type>
Une dclaration comme :
int *PNUM;
Peut tre interprte comme suit :
-
P = &X;
les expressions suivantes, sont quivalentes :
46
Cours du Langage C
*P = *P+10
*P += 2
(*P)++
Professeur : NAMEZ
X = X+10
X += 2
X++
Le pointeur NUL
Seule exception : La valeur numrique 0 (zro) est utilise pour indiquer qu'un pointeur ne pointe
'nulle part'.
int *P;
P = 0;
- Finalement, les pointeurs sont aussi des variables et peuvent tre utiliss comme telles. Soit P1 et
P2 deux pointeurs sur int, alors l'affectation :
P1 = P2;
Copie le contenu de P2 vers P1. P1 pointe alors sur le mme objet que P2.
Rsumons
int A;
int *P;
P = &A;
A
&A
dsigne le contenu de A
dsigne l'adresse de A
P
*P
dsigne l'adresse de A
dsigne le contenu de A
3. Pointeurs et tableaux
En C, il existe une relation trs troite entre tableaux et pointeurs. Ainsi, chaque opration avec des
indices de tableaux peut aussi tre exprime l'aide de pointeurs.
47
Cours du Langage C
Professeur : NAMEZ
En simplifiant, nous pouvons retenir que le nom d'un tableau est un pointeur constant sur le premier
lment du tableau.
Exemple
En dclarant un tableau A de type int et un pointeur P sur int,
int A[10];
int *P;
Linstruction : P = A;
P = A;
Le pointeur P pointe sur A[0], et
*(P+1)
*(P+2)
...
*(P+i)
...
dsigne le contenu de A[i]
*(A+1)
*(A+2)
...
*(A+i)
Attention !
- Un pointeur est une variable, donc des oprations comme P = A ou P++ sont permises.
- Le nom d'un tableau est une constante, donc des oprations comme A = P ou A++ sont
impossibles.
Rsumons
Soit un tableau A d'un type quelconque et i un indice pour les composantes de A, alors :
A
A[0]
dsigne l'adresse de
A+i
A[i]
dsigne l'adresse de
*(A+i) dsigne le contenu de A[i]
Si P = A, alors :
A[0]
48
Cours du Langage C
Professeur : NAMEZ
P+i
A[i]
pointe sur l'lment
*(P+i) dsigne le contenu de A[i]
Formalisme tableau et formalisme pointeur
Les deux programmes suivants copient les lments positifs d'un tableau T dans un deuxime tableau
POS.
Formalisme tableau
main()
{
int T[10] = {-3, 4, 0, -7, 3, 8, 0, -1, 4, -9};
int POS[10];
int I,J; /* indices courants dans T et POS */
for (J=0,I=0 ; I<10 ; I++)
if (T[I]>0)
{
POS[J] = T[I];
J++;
}
return 0;
}
Nous pouvons remplacer systmatiquement la notation tableau[I] par *(tableau + I), ce
qui conduit ce programme:
Formalisme pointeur
main()
{
int T[10] = {-3, 4, 0, -7, 3, 8, 0, -1, 4, -9};
int POS[10];
int I,J; /* indices courants dans T et POS */
for (J=0,I=0 ; I<10 ; I++)
if (*(T+I)>0)
{
*(POS+J) = *(T+I);
J++;
}
return 0;
}
Les variables et leur utilisation
Int A;
A
&A
dsigne le contenu de A
dsigne l'adresse de A
49
Cours du Langage C
B[i]
&B[i]
Professeur : NAMEZ
B+i
dsigne l'adresse de la composante i du tableau
*(B+i) dsigne le contenu de la composante i du tableau
Int *P; dclare un pointeur sur des lments du type int
P
peut pointer
P
*P
P
P+i
*(P+i)
P1 = P2;
Fait pointer P1 sur le mme objet que P2.
- Soustraction de deux pointeurs
Soient P1 et P2 deux pointeurs qui pointent dans le mme tableau :
P1-P2
si P1 prcde P2
si P1 = P2
si P2 precde P1
si P1 et P2 ne pointent pas dans le mme tableau
Plus gnralement, la soustraction de deux pointeurs qui pointent dans le mme tableau est
quivalente la soustraction des indices correspondants.
- Comparaison de deux pointeurs
On peut comparer deux pointeurs par <, >, <=, >=, ==, !=.
50
Cours du Langage C
Professeur : NAMEZ
La comparaison de deux pointeurs qui pointent dans le mme tableau est quivalente la
comparaison des indices correspondants. (Si les pointeurs ne pointent pas dans le mme tableau,
alors le rsultat est donn par leurs positions relatives dans la mmoire).
char *C;
C = "Ceci est une chane de caractres constante";
b) Initialisation
Un pointeur sur char peut tre initialis lors de la dclaration si on lui affecte l'adresse d'une chane de
caractres constante :
51
Cours du Langage C
Professeur : NAMEZ
Chapitre 9 :
LES FONCTIONS
1. Modularisation de programmes
La plupart des langages de programmation nous permettent de subdiviser nos programmes en sousprogrammes, fonctions ou procdures plus simples et plus compacts. A l'aide de ces structures nous
pouvons modulariser nos programmes pour obtenir des solutions plus lgantes et plus efficientes.
Dans ce contexte, un module dsigne une entit de donnes et d'instructions qui fournissent une
solution une (petite) partie bien dfinie d'un problme plus complexe. Un module peut faire appel
d'autres modules, leur transmettre des donnes et recevoir des donnes en retour. L'ensemble des
modules ainsi relis doit alors tre capable de rsoudre le problme global.
Voici quelques avantages d'un programme modulaire :
* Meilleure lisibilit
* Diminution du risque d'erreurs
* Possibilit de tests slectifs
* Dissimulation des mthodes
* Rutilisation de modules dj existants
* Favorisation du travail en quipe
* Hirarchisation des modules
{
<dclarations locales>
<instructions>
}
void HELLO(void);
{
char NOM[20];
printf("Introduisez votre nom : ");
gets(NOM);
printf("Bonjour %s !\n", NOM);
}
52
Cours du Langage C
Professeur : NAMEZ
#include <stdio.h>
main()
{
/* Prototypes des fonctions appeles */
int ENTREE(void);
int MAX(int N1, int N2);
/* Dclaration des variables */
int A, B;
/* Traitement avec appel des fonctions */
A = ENTREE();
B = ENTREE();
printf("Le maximum est %d\n", MAX(A,B));
}
/* Dfinition de la fonction ENTREE */
int ENTREE(void)
{
53
Cours du Langage C
Professeur : NAMEZ
int NOMBRE;
printf("Entrez un nombre entier : ");
scanf("%d", &NOMBRE);
return NOMBRE;
}
/* Dfinition de la fonction MAX */
int MAX(int N1, int N2)
{
if (N1>N2)
return N1;
else
return N2;
}
float PI(void)
54
Cours du Langage C
Professeur : NAMEZ
{
return 3.1415927;
}
Remarques
un type arithmtique,
une structure (dfinie par struct ),
un pointeur,
void (la fonction correspond alors une 'procdure').
Une fonction ne peut pas fournir comme rsultat des tableaux, des chanes de caractres ou des
fonctions. (Attention : Il est cependant possible de renvoyer un pointeur sur le premier lment
d'un tableau ou d'une chane de caractres).
Si une fonction n'a pas de paramtres, on peut dclarer la liste des paramtres comme (void) ou
simplement comme ().
Le type par dfaut est int ; autrement dit : si le type d'une fonction n'est pas dclar explicitement,
elle est automatiquement du type int.
Il est interdit de dfinir des fonctions l'intrieur d'une autre fonction (comme en Pascal).
En principe, l'ordre des dfinitions dans le texte du programme ne joue pas de rle, mais chaque
fonction doit tre dclare ou dfinie avant d'tre appele.
Rappel : main
La fonction principale main est du type int. Elle est excute automatiquement lors de l'appel du
programme. A la place de la dfinition :
int main(void)
On peut crire simplement :
main()
55
Cours du Langage C
Professeur : NAMEZ
4. Renvoyer un rsultat
Par dfinition, toutes les fonctions fournissent un rsultat d'un type que nous devons dclarer. Une
fonction peut renvoyer une valeur d'un type simple ou l'adresse d'une variable ou d'un tableau. Pour
fournir un rsultat en quittant une fonction, nous disposons de la commande return :
return <expression>;
Exemples
La fonction CARRE du type double calcule et fournit comme rsultat le carr d'un rel fourni comme
paramtre.
double CARRE(double X)
{
return X*X;
}
Nous pouvons dfinir nous-mmes une fonction TAN qui calcule la tangente d'un rel X l'aide des
fonctions sin et de cos de la bibliothque <math>.
#include <math.h>
double TAN(double X)
{
if (cos(X) != 0)
return sin(X)/cos(X);
else
printf("Erreur !\n");
}
Si nous supposons les dclarations suivantes
double X, COT;
Les appels des fonctions CARRE et TAN peuvent tre intgrs dans des calculs ou des expressions :
56
Cours du Langage C
Professeur : NAMEZ
Void
En C, il n'existe pas de structure spciale pour la dfinition de procdures comme en Pascal et en
langage algorithmique. Nous pouvons cependant employer une fonction du type void partout o nous
utiliserions une procdure en langage algorithmique ou en Pascal.
Exemple
La fonction du type void LIGNE affiche L toiles dans une ligne :
void LIGNE(int L)
{
/* Dclarations des variables locales */
int I;
/* Traitements */
for (I=0; I<L; I++)
printf("*");
printf("\n");
}
main
Dans nos exemples, la fonction main n'a pas de paramtres et est toujours du type int.
Typiquement, les programmes renvoient la valeur zro comme code d'erreur s'ils se terminent avec
succs. Des valeurs diffrentes de zro indiquent un arrt fautif ou anormal.
void ETOILES(int N)
{
while (N>0)
{
printf("*");
N--;
}
57
Cours du Langage C
Professeur : NAMEZ
printf("\n");
}
En utilisant N comme compteur, nous n'avons pas besoin de l'indice d'aide I comme dans la fonction
LIGNES dfinie plus haut.
La fonction TRIANGLE, appelle la fonction ETOILES en utilisant la variable L comme paramtre :
void TRIANGLE(void)
{
int L;
for (L=1; L<10; L++)
ETOILES(L);
}
Au moment de l'appel, la valeur de L est copie dans N. La variable N peut donc tre dcrmente
l'intrieur de ETOILES, sans influencer la valeur originale de L.
Schmatiquement, le passage des paramtres peut tre reprsent dans une 'grille' des valeurs :
Avantages
Le passage par valeur a l'avantage que nous pouvons utiliser les paramtres comme des variables
locales bien initialises. De cette faon, nous avons besoin de moins de variables d'aide.
58
Cours du Langage C
Professeur : NAMEZ
PERMUTER(X, Y);
Rsultat : X et Y restent inchangs !
Lors de l'appel, les valeurs de X et de Y sont copies dans les paramtres A et B. PERMUTER
change bien contenu des variables locales A et B, mais les valeurs de X et Y restent les mmes.
PERMUTER(&X, &Y);
Rsultat : Le contenu des variables X et Y est chang !
Lors de l'appel, les adresses de X et de Y sont copies dans les pointeurs A et B. PERMUTER
change ensuite le contenu des adresses indiques par les pointeurs A et B.
59
Cours du Langage C
Professeur : NAMEZ
<type> <nom>[]
ou simplement par un pointeur sur le type des lments du tableau :
<type> *<nom>
Exemple
La fonction strlen calcule et retourne la longueur d'une chane de caractres fournie comme
paramtre :
char *S
On aurait aussi pu indiquer :
char S[]
Appel
Lors d'un appel, l'adresse d'un tableau peut tre donne par le nom du tableau, par un pointeur ou par
l'adresse d'un lment quelconque du tableau.
Exemple
Aprs les instructions :
60
Cours du Langage C
Professeur : NAMEZ
strlen(CH) /* rsultat: 9 */
strlen(P) /* rsultat: 9 */
Remarque pratique
Pour qu'une fonction puisse travailler correctement avec un tableau qui n'est pas du type char, il faut
aussi fournir la dimension du tableau ou le nombre d'lments traiter comme paramtre, sinon la
fonction risque de sortir du domaine du tableau.
Exemple
La fonction LIRETAB lit N donnes pour un tableau (unidimensionnel) du type int et les mmorise
partir de l'adresse indique par le pointeur PTAB. PTAB et N sont fournis comme paramtres.
LIRE_TAB(4,T);
Nous obtenons alors les grilles suivantes :
61