Ce programme affichera :A
6.5 Ô tant qu'en emporte le Shadok
Exercice n°6.3—Recommencez ! (a)
Écrivez le programme :Tant que je ne tape pas un nombre impair compris entre 1 et 10 je recommence la saisie d’un nombre.
Exercice n°6.4—Recommencez ! (b)
Écrivez le programme : Tant que je ne tape pas une voyelle je recommence la saisie d’une touche.
6.6 Et les Shadoks continuaient à pomper pour obtenir le résultat
Dans les exercices qui suivent, la notion de compteur intervient. Un compteur est une variable numérique que l’on décrémente (-1) ou incrémente (+1) suivant nos besoins.
Par exemple :
int i;
i=1;
i=i+1;
printf("i vaut: %d",i); // affichera 2
En effet, lorsque nous écrivonsi=1, l’ordinateur range la valeur 1 dans la case mémoire dési-gnée pari. Lorsque nous demandons :i=i+1, l’ordinateur commence par prendre connaissance
de la valeur deien mémoire (ici1) et lui ajoute1. Le résultat est stocké dans la case mémoire associée ài. Finalement,ivaudra 2.
Pour gagner du temps, le langage C nous permet de remplacer une expression comme :i=i+1 par l’expression suivante :i++qui fera exactement la même chose.
int i;
i++; /* Incrémente le compteur i */
i--; /* Décrémente le compteur i */
Dans les exemples précédents, le nombre de caractères entrés peut donc être comptabilisé en ajoutant 1 à une variable à chaque fois qu’une touche est frappée.
Exercice n°6.5—Recommencez ! (c)
Écrivez le programme :Tant que je n’ai pas saisi 10 nombres, je recommence la saisie d’un nombre.
Exercice n°6.6—Recommencez ! (d)
Écrivez le programme :Tant que je n’ai pas saisi 10 caractères, je recommence la saisie d’un caractère.
Dans les exercices qui précèdent, de petites difficultés peuvent surgir… Nous vous invitons donc à vous pencher plus rapidement sur la solution.
6.7 Dans le clan des Shadoks, on trie, voyelles, chiffres premiers
Exercice n°6.7—Recommencez ! (e)
Écrivez le programme :Tant que je n’ai pas saisi 10 voyelles, je recommence la saisie d’une touche. Vous prendrez soin d’indiquer à l’utilisateur combien de voyelles il lui reste à entrer.
Exercice n°6.8—Recommencez ! (f)
Écrivez le programme :Tant que je n’ai pas saisi 10 chiffres premiers (2,3,5 ou 7), je recommence la saisie d’un chiffre. Vous prendrez soin d’indiquer à l’utilisateur combien de chiffres premiers il lui reste à entrer.
6.8 Incrémentations, pré-incrémentations…
Nous avons vu qu’incrémenter désignait la même chose qu’augmenter la valeur d’une variable de 1 :
i++;⇐⇒ i=i+1 ; Il y a cependant une nuance subtile.
6.8 Incrémentations, pré-incrémentations… 45
x=i++ Copie d’abord la valeur deidansxet incrémentei après x=i-- Copie d’abord la valeur deidansxetdécrémente iaprès x=++i Incrémente i d’abordpuis copie le contenu deidansx x=--i Décrémente id’abordpuis copie le contenu dei dansx
Table 6.1 - Incrémentation / Décrémentation
Pour bien comprendre, étudions le programme suivant :
#include <stdio.h>
int main () { int n=5;
int x;
x=n++;
printf ("x: %d n: %d\n",x,n);
return 0;
}
Celui-ci retourne le résultat suivant :
x: 5 n: 6
Analysons ce qui se passe lors de l’application de la ligne (x=n++) : 1. on affectenà x, doncxva contenir la valeur5
2. on augmentende1, doncnvaudra6
On parlera dans ce cas d’incrémentation post-fixée…
Voici un autre exemple :
#include <stdio.h>
int main () { int n=5;
int x=0;
x=++n;
printf ("x: %d n: %d\n",x,n);
return 0;
}
Celui-ci retourne le résultat suivant :
x: 6 n: 6
Analysons ce qui se passe lors de l’application de la ligne(x=++n) : 1. on augmentende1, doncnvaudra6
2. on affectenà x, doncxva contenir la valeur6 On parlera dans ce cas d’incrémentation pré-fixée…
6.9 Corrigés des exercices du chapitre
Corrigé de l’exercice n°6.1—Touche-touche
#include <stdio.h>
int main () { char car = '\0';
printf("Tapez 's' ou 'S' pour arrêter ...\n");
do {
car = getchar ();
}while ((car != 's') && (car != 'S'));
return 0;
}
Corrigé de l’exercice n°6.2—Saisir un nombre
#include <stdio.h>
int main () { int nbre = 0;
printf("Tapez 10 pour arrêter ...\n");
do {
scanf ("%d", &nbre);
}while (nbre != 10);
return 0;
}
Corrigé de l’exercice n°6.3—Recommencez ! (a)
#include <stdio.h>
int main () { int nbre = 0;
printf("Tapez un chiffre impair pour arrêter ...\n");
while ((nbre!=1) && (nbre!=3) && (nbre!=5) && (nbre!=7) && (nbre!=9)) scanf("%d", &nbre);
printf("Tapez un chiffre impair pour arrêter ...\n");
while ((nbre < 0) || (nbre >= 10) || (nbre%2==0)) scanf("%d", &nbre);
return 0;
}
6.9 Corrigés des exercices du chapitre 47
Corrigé de l’exercice n°6.4—Recommencez ! (b)
#include <stdio.h>
#include <ctype.h>
int main () { char car = '\0';
printf("Tapez une voyelle pour arrêter ...\n");
while ((car != 'A') && (car != 'E') && (car != 'I') &&
(car != 'O') && (car != 'U') && (car != 'Y')){
car = getchar ();
car = toupper (car);
}
return 0;
}
Corrigé de l’exercice n°6.5—Recommencez ! (c) [Il conviendrait dans cet exercice de vérifier que l’utilisateur a bien entré uniquement des nombres et pas aussi des caractères.
Le lecteur intéressé pourra consulter la documentation descanf et essayer d’utiliser la valeur que renvoie cette fonction pour régler ce problème.]
#include <stdio.h>
int main () { int nbre = 0;
int nb_nbre = 0;
printf("Tapez 10 nombres pour arrêter ...");
do {
scanf("%d",&nbre);
nb_nbre ++;
}while (nb_nbre != 10);
return 0;
}
Corrigé de l’exercice n°6.6—Recommencez ! (d)
Prenez soin de lire l’exemple d’exécution et son explication :
#include <stdio.h>
int main () { char car = '\0';
int nbre = 0;
printf("Tapez 10 caractères pour arrêter ...");
do {
car = getchar ();
nbre ++;
printf("j'ai lu (%c) nbre=%d\n",car,nbre);
}while (nbre != 10);
return 0;
}
Voici un exemple d’exécution :
Tapez 10 caractères pour arrêter ... 123456789 j'ai lu (1) nbre=1
L’utilisateur a donc tapé123456789suivi de la touche entrée, il a donc bien tapé 10 caractères. Ce que montre l’affichage de la dernière ligne avec la parenthèse ouvrante sur une ligne et la parenthèse fermante sur la ligne suivante.
Vous pouvez faire d’autres essais…
Corrigé de l’exercice n°6.7—Recommencez ! (e)
#include <stdio.h>
#include <ctype.h>
int main () { char car;
int nb_nbre = 10;
printf("Tapez encore %d voyelles pour arrêter...\n",nb_nbre);
do {
car=getchar();
car=toupper(car);
if (car=='A' || car=='E' || car=='I' || car=='O' || car=='U') { nb_nbre--;
printf("Tapez encore %d voyelles pour arrêter...\n",nb_nbre);
} }
while (nb_nbre != 0);
return 0;
}
Corrigé de l’exercice n°6.8—Recommencez ! (f)
#include <stdio.h>
#include <ctype.h>
int main () { int nb_nbre = 10;
int nbre;
printf("Tapez encore %d chiffres premiers...\n",nb_nbre);
6.10 À retenir 49
do {
scanf("%d",&nbre);
if (nbre==2 || nbre==3 || nbre==5 || nbre==7) { nb_nbre--;
printf("Tapez encore %d chiffre(s) premier(s) pour arrêter...\n", → ,→ nb_nbre);
} }
while (nb_nbre != 0);
return 0;
}
6.10 À retenir
Voici un exemple de programme qui résume ce qui a été vu dans ce chapitre. Ce programme doit afficher à l’écran tous les nombres pairs inférieurs à 100 :
#include <stdio.h>
Voici une autre version (meilleure) :
#include <stdio.h>
Enfin, n’oubliez pas le tableau :
x=i++ Copie d’abord la valeur deidansxet incrémentei après x=i-- Copie d’abord la valeur deidansxetdécrémente iaprès x=++i Incrémente i d’abordpuis copie le contenu deidansx x=--i Décrémente id’abordpuis copie le contenu dei dansx
Table 6.2 - Incrémentation / Décrémentation (bis)
Chapitre
7
Boucles
7.1 Et les Shadoks pédalèrent pendant 15 tours
Afin d’effectuer un certain nombre de fois une tâche, nous utilisons l’instruction for de la façon suivante (avec i, une variable de type entier (int par exemple)) :
for (i=point de départ; i<point d'arrivée; i=i+pas) { instruction(s) répétées(s);
}
Ceci est rigoureusement équivalent à cela :
i=point de départ;
while (i<point d'arrivée) { instruction(s) répétées(s);
i=i+pas;
}
Par souci de simplicité, nous dirons simplement que l’incantation suivante :
51
for (i=0; i<15; i++) { instr;
}
signifie que l’on va exécuterinstrpourivariant de0à14 inclus (<15) c’est à dire15fois.
Par exemple :
#include <stdio.h>
int main () { int i;
for (i=0; i<15; i++){
printf("Je me répète pour i valant %d\n",i);
}
printf("L'instruction a été répétée... 15 fois\n");
return 0;
}
7.2 Syntaxe
De la même façon que leif, leforne nécessite pas d’accolades s’il n’y a qu’une instruction à répéter.
Nous pouvons utiliser cette fonctionnalité dans le programme précédent en rempla-çant :
for (i=0; i<15; i++) {
printf("Je me répète pour i valant %d\n",i);
}
par :
for (i=0; i<15; i++)
printf ("Je me répète pour i valant %d\n",i);
7.3 Notion de double boucle
Il est possible de remplacer les instructions contenues dans une boucle par une autre boucle afin de réaliser une double boucle. Nous obtenons donc :
Pour i allant de ... à ... { ...
Pour j allant de ... à ... { ...
} }
7.4 Et les Shadoks fêtèrent Noël… 53
printf("\nJe suis dans la boucle i, i vaut %d\n",i);
for (j=3; j>0; j--)
printf("Je suis dans la boucle j, j vaut %d\n",j);
}
return 0;
}
Exercice n°7.1—Étoiles
En utilisant une double boucle, écrire un programme qui affiche une étoile, passe à la ligne, affiche deux étoiles, passe à la ligne, affiche trois étoiles… jusqu’à cinq étoiles afin d’obtenir ceci :
7.4 Et les Shadoks fêtèrent Noël…
7.4.1 Affichage des ramures du sapin
Exercice n°7.2—Sapin
À l’aide d’une double boucle, réalisez un cône pour dessiner le haut du sapin sur 10 lignes.
Vous devriez obtenir ceci :
*
Instructions :
– sur la ligne no1, afficher 9espaces puis1étoile ; – sur la ligne no2, afficher 8espaces puis3étoiles ; – sur la ligne no3, afficher 7espaces puis5étoiles ;
– sur la ligne noi, afficher 10-iespaces puis2*i-1étoiles.
Nous obtenons donc par exemple pour l’affichage des étoiles sur la lignei :
for (j=0; j<((2*i)-1); j++) { printf ("*");
}
7.4.2 Affichage du tronc
Exercice n°7.3—Tronc
Pour poursuivre le sapin, il nous faut maintenant dessiner le tronc. Écrivez la suite du programme en dessinant le tronc à l’aide du caractère@. Vous devriez obtenir ceci (juste pour le tronc) :
@@@
@@@
@@@
7.5 Table Ascii
Les codes Ascii (c’est-à-dire les nombres qui représentent les caractères en informatique) vont de0à255.
Exercice n°7.4—Code Ascii
Écrivez un programme qui fait afficher, sur des lignes successives, les codesAsciiavec les caractères qui leur correspondent (vous pouvez commencer l’affichage à partir du code32 et vous arrêter au code127).
Pour faire afficher le caractère associé à un code Ascii, vous utiliserez l’instruction ci-dessous (le%3dsignifie que le nombre va être affiché en utilisant un emplacement qui fait trois caractères de long) :
printf ("%3d : %c", code ascii, code ascii) ;
Par exemple :
int i = 65;
printf("%3d : %c", i, i); // affichera 65 : A
7.6 Corrigés des exercices du chapitre 55
Exercice n°7.5—Un beau tableau
Même chose, mais avec un joli affichage, par exemple sous la forme d’un tableau sur huit colonnes…
7.6 Corrigés des exercices du chapitre
Corrigé de l’exercice n°7.1—Étoiles
#include <stdio.h>
Nous aurions aussi pu écrire :
#include <stdio.h>
for (j=1; j<=i; j++) // pas d'accolades nécessaires...
printf("*");
printf("\n");
}
return 0;
}
Corrigé de l’exercice n°7.2—Sapin
#include <stdio.h>
for (j=0;j<10-i;j++) // les espaces...
printf(" ");
for (j=0; j<(i*2-1); j++) printf("*");
printf("\n");
}
return 0;
}
Corrigé de l’exercice n°7.3—Tronc Vous ajoutez ceci :
...
for (i=1; i<=3; i++) printf(" @@@\n");
...
Corrigé de l’exercice n°7.4—Code Ascii
#include <stdio.h>
#include <stdlib.h>
int main () { int i;
int j;
for (i=32; i<128; i++) printf("%3d %c\n",i,i);
return 0;
}
Corrigé de l’exercice n°7.5—Un beau tableau
#include <stdio.h>
#include <stdlib.h>
int main () { int i;
int j;
for (i=4; i<16; i++) { for(j=0; j<8; j++) {
printf("%3d %c ",i*8+j,i*8+j);
}
printf("\n");
}
return 0;
}
7.7 À retenir 57
7.7 À retenir
Retenez l’équivalence entre les deux programmes suivants :
for (i=1; i<100; i=i+2) { printf("i vaut:%d",i);
}
i=1;
while (i<100) {
printf("i vaut:%d",i);
i=i+2;
}
Chapitre
8
Pointeurs et fonctions
8.1 Objectifs
Dans ce chapitre, nous manipulerons deux notions essentielles du langage C : les pointeurs et les fonctions…
8.2 Binaire, octets…
8.2.1 Binaire
L’ordinateur ne « comprend » que des0et des1. On dit qu’il travaille en base 2 ou binaire (tout simplement parce que ce système de numération est particulièrement adapté à la technologie électronique utilisée pour construire les ordinateurs). Au contraire des machines, les humains préfèrent généralement la base 10, c’est à dire le système décimal.
La table 8.1 donne l’écriture binaire et décimale de quelques nombres.
Nous voyons dans cette table que le nombre 7 est donc représenté par trois symboles «1» qui se suivent :111.
59
Binaire Décimal
0 0
1 1
10 2
11 3
100 4
101 5
110 6
111 7
1000 8
1001 9
1010 10
... ...
11111111 255
Table 8.1 - Équivalences entre l’écriture binaire et l’écriture décimale
Chacun de ces «1» et «0» s’appelle un bit (contraction de l’anglais binary digit : chiffre binaire). Par exemple, le nombre «1010001» est composé de 7 bits.
Un ensemble de huit bits consécutifs (chacun pouvant prendre la valeur 0 ou 1), s’appelle un octet (byteen anglais).
– 11110000représente un octet – 10101010représente un octet
– 100011101ne représente pas un octet
8.2.2 Compter en base 2, 3, 10 ou 16
Vous avez l’habitude de compter en base 10 (décimal). Pour cela, vous utilisez dix chiffres de 0à 9.
Pour compter en base 2 (binaire), on utilisera deux chiffres :0et1. Pour compter en base 3, on utilisera 3 chiffres :0,1et2.
La base 16 (base hexadécimale) est très utilisée en informatique et notamment en langage assembleur. Mais compter en hexadécimal nécessite d’avoir 16 chiffres ! La solution est de compléter les chiffres habituels de la base 10 par des lettres de l’alphabet comme le montre le tableau 8.2.
8.3 Variables : pointeurs et valeurs 61
Base 16 Base 10
0 0
1 1
2 2
3 3
4 4
5 5
6 6
7 7
8 8
9 9
A 10
B 11
C 12
D 13
E 14
F 15
Table 8.2 - Base 16 et base 10
Dans la pratique, afin de ne pas faire de confusion entre le nombre 10 (en décimal) et ce même nombre en hexadécimal, on précède ce dernier par le préfixe «0x» :
int i1=10;
int i2=0x10;
printf("i1=%d i2=%d",i1,i2);
Ce programme afficherai1=10 i2=16.
8.3 Variables : pointeurs et valeurs
8.3.1 Variables et mémoire
Une variable est une zone mémoire disponible pour y ranger des informations. Par exemple, dans le cas d’une variable car déclarée par char car ;, la zone mémoire disponible sera de 1 octet (exactement une case mémoire). En revanche, une variable de type int utilisera au moins 4 octets (la valeur exacte dépend du compilateur), c’est à dire 4 cases mémoires.
À présent, représentons-nous la mémoire comme une unique et longue « rue » remplie de maisons. Chaque case mémoire est une maison. Chaque maison porte un numéro, c’est ce qui permet de définir son adresse postale. Cette adresse est unique pour chaque maison dans la rue.
De manière analogue, pour une case mémoire, on parlera d’adresse mémoire.
Par exemple, ce petit programme va afficher l’adresse mémoire d’une variable de type caractère.
#include <stdio.h>
int main () { char c='A';
printf ("c contient %c et est stocké à %p\n",c,&c);
return 0;
}
L’exécution nous donne, par exemple :
c contient A et est stocké à 0xbf8288a3
Le format «%p» permet d’afficher une adresse en hexadécimal.
Vous pouvez essayer le programme précédent, mais vous n’aurez probablement pas la même adresse mémoire que dans l’exemple.
8.3.2 Pointeurs
Pour manipuler les adresses mémoire des variables, on utilise des variables d’un type spécial : le type « pointeur ». Une variable de type pointeur est déclarée ainsi :
type* variable;
L’espace après*peut être omis ou placé avant, peu importe.
C’est le signe* qui indique que nous avons affaire à un pointeur. L’indication qui précède* renseigne le compilateur sur le type de case pointée, et comment se comporteront certaines opérations arithmétiques1. Si v est un pointeur vers un int, et que nous désirons modifier l’entier pointé, nous écrirons :
*v = valeur;
*vpeut être interprété comme « contenu de l’adresse mémoire pointée par v ».
Lisez le programme suivant ainsi que les explications associées.
#include <stdio.h>
int main () { char car='C';
char * ptr_car; /* Variable de type pointeur */
printf("Avant, le caractère est : %c\n",car);
ptr_car = &car; /* ptr_car = adresse de car */
1. Ajouter 1 à un pointeur sur unintrevient à ajouter 4 à l’adresse, alors qu’ajouter 1 à un pointeur sur uncharrevient à n’ajouter que 1 à l’adresse.
8.3 Variables : pointeurs et valeurs 63
*ptr_car = 'E'; /* on modifie le contenu de l'adresse mémoire */
printf("Après, le caractère est : %c\n\n",car);
printf("Cette modification est due à :\n");
printf("Adresse de car : %p\n",&car);
printf("Valeur de ptr_car : %p\n",ptr_car);
return 0;
}
Voici ce que cela donne avec notre rue bordée de maisons :
ptr car = &car ; ptr carcontient l’adresse postale de Monsieurcar
*ptr car = ’E’ ;
On entre chez Monsieurcaret on y dépose le
caractèreE
printf ("%c",car) ;
On va regarder ce qu’il y a chez Monsieurcarpour l’afficher à l’écran Table 8.3 - –Pointeurs et valeurs
On supposera que la variable car est stockée à l’adresse 0x0100; la variable ptr car est stockée à l’adresse0x0110.
Reprenons les deux premières lignes d’exécution du programme :
char car='C';
char* ptr_car;
La mémoire ressemble alors à ceci :
Nom de la variable car ptr car
Contenu mémoire C ?
Adresse mémoire (0x) 100 110 Table 8.4 - Stockage de variables (a)
Nous mettons « ? » comme contenu deptr carcar cette variable n’a pas encore été initialisée.
Sa valeur est donc indéterminée.
Le programme se poursuit par :
printf("Avant, le caractère est : %c\n",car);
ptr_car = &car; /* ptr_car = adresse de car */
Il y aura donc affichage à l’écran deAvant, le caractère est : C puis la mémoire sera modifiée comme ceci :
Nom de la variable car ptr car
Contenu mémoire C 100
Adresse mémoire (0x) 100 110 Table 8.5 - Stockage de variables (b)
ptr carn’est donc qu’une variable, elle contient la valeur100(l’adresse de la variablecar).
Finalement, la ligne :
*ptr_car = 'E'; /* on modifie le contenu de l'adresse mémoire */
conduit à modifier la mémoire comme suit :
Nom de la variable car ptr car
Contenu mémoire E 100
Adresse mémoire (0x) 100 110 Table 8.6 - Stockage de variables (c)
Prenez le temps de comprendre tout ce qui précède avant de passer à la suite.
8.3.3 Exercice d’application
Exercice n°8.1—Intelligent
Réalisez un programme équivalent qui change une valeur numérique (int) de 10 à 35.
Notons que, dans la pratique, lorsque l’on déclare un pointeur, il est plus prudent de l’initialiser :
#include <stdio.h>
int main () { char car='C';
char * ptr_car=NULL;
printf("Avant, le caractère est : %c\n",car);
ptr_car = &car; /* ptr_car = adresse de car */
*ptr_car = 'E'; /* on modifie le contenu de l'adresse mémoire */
printf("\nAprès le caractère est : %c\n",car);/*on a modifié car*/
return 0;
}
8.4 Fonctions 65
La constanteNULLvaut0. Or un programme n’a pas le droit d’accéder à l’adresse 0. Dans la pratique, écrireprt car=NULLsignifie que l’adresse mémoire pointée est pour l’instant invalide.
On peut se demander à quoi servent les pointeurs ? ! En effet, ceci a l’air compliqué alors que l’on pourrait faire bien plus simple.
Ainsi tout le travail effectué par le programme précédent se résume au code suivant :
#include <stdio.h>
int main () { char car='C';
printf("Avant, le caractère est : %c\n",car);
car='E';
printf("\nAprès le caractère est : %c\n",car);/*on a modifié car*/
return 0;
}
Nous verrons par la suite que dans certains cas, on ne peut pas se passer des pointeurs, notamment pour certaines manipulations au sein des fonctions…
8.4 Fonctions
Une fonction est un petit bloc de programme qui à l’image d’une industrie va créer, faire ou modifier quelque chose. Un bloc de programme est mis sous la forme d’une fonction si celui-ci est utilisé plusieurs fois dans un programme ou simplement pour une question de clarté. De la même manière que nous avions défini la fonction main, une fonction se définit de la façon suivante :
<type de sortie> <nom de la fonction> (<paramètres d'appels>) { Déclaration des variables internes à la fonction
Corps de la fonction Retour
}
Comme indiqué précédemment, il ne faut pas mettre les < et >, qui ne sont là que pour faciliter la lecture.
Voici un exemple de fonction qui renvoie le maximum de deux nombres :
int maximum (int valeur1, int valeur2) { int max;
Le programme complet pourrait être le suivant :
01. #include <stdio.h>
02.
03. int maximum (int valeur1, int valeur2) { 04. int max;
14. printf("entrez 1 valeur:");
15. scanf("%d",&i1);
16. printf("entrez 1 valeur:");
17. scanf("%d",&i2);
18. printf("max des 2 valeurs :%d\n",maximum(i1,i2));
19. return 0;
20. }
– Dans la pratique (et en résumant un peu), quand vous tapez ./programme pour lancer votre programme, l’ordinateur exécute la fonctionmainqui se trouve à la ligne 12. L’ordinateur demande donc ensuite d’entrer deux valeurs qui seront stockées dansi1eti2.
– Supposons que l’utilisateur ait entré les valeurs111 et222.
– Arrivé à l’exécution de la ligne 18, la machine doit appeler la fonctionprintf, et pour cela, chacun des paramètres de la fonction doit être évalué.
– L’exécution passe alors à la fonction maximum, ligne 3. À ce niveau, on peut com-prendre intuitivement que la variablevaleur1 prend la valeur de i1 (c’est-à-dire 111) et la valeurvaleur2prend la valeur dei2(c’est-à-dire222), du fait de l’appel demaximum(i1,i2).
– La fonctionmaximumse déroule. Après avoir passé les lignes4à8, la valeur demax sera de222.
– À la ligne 9 on sort donc de la fonction maximum pour revenir à l’appel fait par printf de la ligne 18. Tous les paramètres de la fonction ayant été évalués (maximum(i1,i2)a été évalué à 222),printfest exécuté et dans le format, «%d» est remplacé par 222.
– Le programme se termine.
8.4.1 Type void
Le motvoidsignifie vide. Le typevoidest notamment utilisé comme type de sortie pour les fonctions qui ne retournent aucun résultat (qu’on appelle aussi procédures).
Exemple :
/* Fonction affichant un caractère */
void affiche_car (char car) { printf ("%c",car);
}
8.4 Fonctions 67
Exemple de programme complet :
#include <stdio.h>
/* Fonction affichant un caractère */
void affiche_car (char car) { printf ("%c",car);
}
int main () { char c;
int i;
printf("Veuillez entrer un caractère:");
scanf("%c",&c);
for (i=0; i<100; i++) affiche_car(c);
return 0;
}
8.4.2 Variables globales et locales
Les variables déclarées dans les fonctions sont dites locales. Il existe aussi les variables dites globales qui sont déclarées en-dehors de toute fonction (y compris lemain()).
Les variables globales sont modifiables et accessibles par toutes les fonctions sans avoir besoin de les passer en paramètres. Il est de ce fait extrêmement dangereux d’utiliser des variables globales.
Les variables locales ne sont modifiables et accessibles que dans la fonction où elles sont déclarées. Pour les modifier ou les utiliser dans une autre fonction, il est nécessaire de les passer en paramètres.
8.4.2.1 Variables locales
int val_retour = 0; /* Variable locale */
val_retour = carre (2);
printf("Le carré de 2 est : %d\n", val_retour);
return 0;
}
La variable val retour de main et la variable v de carre sont toutes deux des variables locales. Le passage des valeurs se fait par copie. Lors du return v, on peut imaginer que
c’est le contenu dev qui est renvoyé, puis stocké dansval retour. La variable vest détruite lorsqu’on revient dansmain.
8.4.2.2 Variables globales
#include <stdio.h>
int val = 0;
int val_retour = 0;
void carre () {
val_retour = val * val;
}
int main () { val = 2;
carre ();
printf("Le carré de 2 est %d\n", val_retour);
return 0;
}
Les variables val et val retour sont des variables globales. On constate que le programme devient rapidement illisible et difficile à vérifier…
Le conseil à retenir est de ne pas utiliser de variable(s) globale(s) lorsqu’il est possible de s’en passer.
8.4.3 Utilisation et modification de données dans les fonctions
L’appel d’une fonction peut s’effectuer à l’aide de paramètres.
Ces paramètres figurent dans les parenthèses de la ligne de titre de la fonction.
Ces paramètres figurent dans les parenthèses de la ligne de titre de la fonction.