Vous êtes sur la page 1sur 14

Les fonctions

Les boucles
Dcouper son projet
Nous avons dcouvert beaucoup de nouveauts dans les chapitres prcdents. Nos programmes commencent grossir,
mme s'ils restent encore modestes. C'est pourquoi il est important d'apprendre dcouper son programme
en fonctions.

A quoi ca sert ?
Dclarer une fonction
Utiliser une fonction
Les prototypes
Exercices

A quoi ca sert ?
Les fonctions ne sortent pas de nulle part : si on les a inventes, c'est qu'elles peuvent servir quelque chose. Reste
comprendre pourquoi. Car les fonctions sont des inventions qui rpondent des besoins bien prcis : grandement
faciliter la vie du programmeur !
Lorsque vous crez un programme, le rsultat sera une grosse suite d'instructions places les unes la suite des autres.
Et parmi cette gigantesque suite d'instructions, il y a souvent des "sous-suites", des paquets d'instructions, des
morceaux de code qui reviennent rgulirement et qui sont prsents en plusieurs exemplaires dans le programme final.
Ces sous-suites servent pratiquement toujours excuter une tche bien prcise et ont presque toujours une
signification importante pour le programmeur. Par exemple, il va exister une de ces sous-suites qui va servir calculer
un rsultat bien prcis, communiquer avec un priphrique, ou autre chose encore.

Sans fonctions
Sans utiliser de fonctions, ces suites d'instructions sont prsentes en plusieurs exemplaires dans le programme. Le
programmeur doit donc recopier chaque fois ces suites d'instructions, ce qui ne lui facilite pas la tche. Et dans
certains programmes, devoir recopier plusieurs fois la squence d'instruction qui permet d'agir sur un priphrique ou
de faire une action spciale est franchement barbant !
De plus, ces suites d'instructions sont prsentes plusieurs fois dans le programme final, excut par l'ordinateur. Et
elles prennent de la place inutilement ! Mine de rien, chaque fois qu'on recopie une de ces suites d'instructions
rcurrentes, on rinvente la roue. On perd ainsi beaucoup de temps faire du copier-coller o rcrire ce qui a dj
t fait. Les informaticiens ont donc invent un moyen qui permet ces suites d'instructions d'tre prsentes une seule
fois dans le programme et d'tre rutilisables au besoin. On a donc invent les fonctions.

Avec les fonctions


La technique du sous-programme consiste n'crire qu'un seul exemplaire de ces suites d'instructions, et lui donner un
nom. Au lieu de recopier cet exemplaire chaque fois qu'on veut le rutiliser, il suffira tout simplement de placer son
nom la place. On appellera cette suite d'instruction une fonction.
Cet exemplaire sera crit en dehors du programme principal, le fameux main que l'on utilise depuis le dbut. On peut
remarquer que la fonction main est dj une fonction, qui regroupe tout le programme.
Les fonctions, qui sont des bouts de code rutilisables au besoin, prsentent ainsi de gros avantages.

Elles sont rutilisables. Plus besoin de recopier btement du code plusieurs fois de suite ! Avec une fonction,
il suffit d'crire une seule fois la fonction et ensuite de l'appeler autant de fois que l'on veut.
Elles sont plus facilement maintenables : si votre fonction est inadapte, il suffit d'en changer le code. C'est
beaucoup plus rapide que de modifier plusieurs exemplaires d'une mme suite d'instruction, surtout s'ils sont
dissmins n'importe comment dans tout le programme.
Elles permettent de mieux s'organiser : en divisant le code en fonctions, on peut ainsi sparer les diffrentes
oprations et mieux s'y retrouver lors de la relecture du code. C'est quand mme plus agrable de lire un code
bien ar qu'une gigantesque suite d'instructions de 2000 lignes dans laquelle tout est mlang n'importe
comment.
Bref, les fonctions n'ont que des avantages. Reste savoir comment faire pour crer notre fonction, ce que nous allons
voir ds la sous-partie suivante.

Dclarer une fonction


Une fonction n'est donc qu'un vulgaire bloc de code, un morceau de programme. Mais ce morceau de programme a
tout de mme quelques caractristiques.
Par exemple, imaginons que je veuille crer une fonction qui calcule une opration mathmatique complexe. On va
prendre le logarithme d'un nombre, par exemple (si vous ne savez pas ce que c'est, ce n'est pas important). Notre
fonction va donc devoir manipuler un nombre, celui dont on veut calculer le logarithme. De mme, elle va fournir un
rsultat, le logarithme du nombre. Avec cet exemple, on voit qu'une fonction doit tre dfinie par trois lments.
Elle a parfois besoin de paramtres : ce sont toutes les informations que l'on donne la fonction pour qu'elle puisse
travailler. Ces informations vont donner des donnes que notre fonction va devoir manipuler afin d'obtenir un rsultat.
Dans notre exemple, le nombre dont on veut calculer le logarithme est un paramtre de la fonction.
Elle contient aussi du code : ce code va dire ce que va faire la fonction. C'est tout ce qui compose l'intrieur d'une
fonction, une fonction sans code, une fonction vide entre autres est une fonction inutile.
Et enfin, notre fonction peut renvoyer un rsultat. Ce n'est pas obligatoire d'en renvoyer un, mais la majorit des
fonctions renvoient un rsultat.

Dclarer une fonction


Maintenant que vous avez vu la partie "thorique", regardons comment tout cela s'applique en C. On vient de voir
qu'une fonction est constitue de plusieurs lments. Tous ces lments seront donc indiqus dans notre fonction, des
endroits diffrents. Mais commenons par le commencement : nous allons d'abord apprendre dclarer une fonction :
cela consiste indiquer notre langage qu'on veut crer une fonction. Une fois celle-ci dclare, il ne restera plus qu'
dire ce qu'elle fait, en crivant son code et en spcifiant le rsultat.
Pour dclarer une fonction, nous allons devoir donner quelques informations sur notre fonction, et notamment sur ses
arguments et sur son rsultat. Ces fameuses informations sont :

le type de retour : il s'agit du type du rsultat de la fonction. Aprs tout, notre fonction pourrait aussi bien
renvoyer un nombre entier, qu'un flottant ou un caractre, aussi prciser le type du rsultat est obligatoire.
le nom de la fonction : c'est vous qui le choisissez. Les rgles sont les mmes que pour les variables.
les paramtres : les paramtres sont ce avec quoi la fonction va travailler. Vous pouvez en mettre autant que
vous voulez.
Pour dclarer une fonction, il va falloir prciser ces trois dtails. Voici comment procder pour prciser ces trois
paramtres et ainsi dclarer une fonction :

1 type identificateur (paramtres)


2{
3
/* corps de la fonction */
4}

l'intrieur de notre fonction (dans ce qui est nomm le corps de la fonction dans l'exemple du dessus), on va y placer
le code de notre fonction. Pour illustrer ce concept, prenons un exemple tout banal :

1 int ma_fonction(int parametre)


2{
/* Instructions */
3
4}
J'ai ici dfini une fonction appele ma_fonction. Elle prend un int comme paramtre, et a pour rsultat un int.

void
Il se peut que l'on est besoin de coder une fonction qui ne retourne aucun rsultat. C'est un cas courant en C. Ce genre
de fonction est appelprocdure. Pour crire une procdure, il faut indiquer la fonction en question qu'elle ne doit
rien retourner. Pour ce faire, il existe un "type de retour" spcial : void. Ce type signifie "vide", et sert indiquer que
la fonction n'a pas de rsultat.
Ce mot-clef sert aussi indiquer qu'une fonction ne prend aucun paramtre. C'est assez rare, mais cela arrive. Dans ce
cas, il suffit de dfinir la fonction en mettant void dans la liste des paramtres.

Paramtres
Un paramtre sert fournir des informations la fonction lors de son excution. La fonction printf par exemple
rcupre ce qu'elle doit afficher dans la console l'aide de paramtres. Vous pouvez envoyer autant de paramtres
une fonction que vous voulez, il suffit de les sparer l'aide d'une virgule. Cependant, ils doivent avoir des noms
diffrents, tout comme les variables. Il est aussi possible de ne pas mettre d'arguments dans notre fonction, comme
indiqu plus haut.

Exemples
Pour vous faire bien saisir toutes ces notions, entrainez vous dclarer des fonctions. Essayez de dclarer une fonction
:

retournant un double et prenant un char et un int en argument ;


retournant un unsigned short et ne prenant aucun paramtre ;
retournant un float et prenant un int, un long et un double en paramtres ;
retournant un int et prenant un int constant et un unsigned long en paramtre ;
ne retournant rien et ne prenant aucun paramtre ;
Je pense qu'avec tous ces exemples vous commencez bien saisir comment dclarer une fonction.

Le corps d'une fonction


Intressons-nous maintenant au corps de la fonction, le code qu'il y a l'intrieur. Comme pour la fonction main, le
code est l'intrieur des accolades. Et ce code, c'est nous qui allons l'crire. Alors que doit-on crire ? En bref, ce que
vous voulez que la fonction fasse.

return
ce stade, vous savez comment dclarer une fonction sans problme. Il vous manque juste une dernire information :
comment faire pour prciser quel est le rsultat de la fonction ? Comment lui dire : Le rsultat que tu dois renvoyer,
c'est a ? Pour cela, on doit utiliser le mot-clefreturn. Une fois que vous avez une variable qui contient le rsultat
que vous voulez, il suffit d'crire return, suivi du nom de la variable, le tout suivi d'un point-virgule. ce momentl, la fonction sarrtera et renverra son rsultat immdiatement. Cela signifie que tout le code qui est crit aprs
le return ne sera pas excut : notre fonction a dj son rsultat de disponible, pourquoi faire quoi que ce soit de plus
?

Petite remarque : un return peut parfaitement renvoyer une valeur qui est une constante. Pour donner un exemple, on
va prendre une fonction assez simple, qu'on nommera valueSign. Notre fonction va prendre un argument de
type int en entre et va renvoyer :

0 si cet argument est nul ;


1 si celui-ci est positif ;
et -1 si celui-ci est ngatif.
Une version nave de cette fonction s'crirait comme ceci :

1 int
2{
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17 }

valueSign (int a)
if ( a > 0 )
{
return 1 ;
}
else if ( a < 0 )
{
return -1 ;
}
else
{
return 0 ;
}

Variables locales
Autre dtail, qui concerne les variables que vous dclarez l'intrieur du corps d'une fonction. Autant vous prvenir
tout de suite : n'essayez pas daccder une variable qui est dclare dans une fonction en dehors de celle-ci. Si vous
faites cela, vous allez au-devant de graves ennuis.
En effet, sauf cas exceptionnels, il faut savoir que ces variables ne sont accessibles que dans notre fonction, et pas de
l'extrieur. C'est ainsi : les variables dclares l'intrieur de la fonction sont des donnes temporaires qui lui
permettent de faire ce qu'on lui demande. Ces donnes sont des donnes internes notre fonction, qu'elle seule doit
manipuler et qui ne doivent gnralement pas tre accessibles dautres programmes ou d'autres fonctions. Si ce n'est
pas le cas, c'est que cette variable doit tre passe en paramtre ou qu'elle doit tre renvoye en tant que rsultat.
En fait, vous pouvez considrer que dans la majorit des cas, ces variables dclares dans une fonction sont cres
quand on commence lexcution de la fonction, et qu'elles sont enleves de la mmoire une fois que la fonction
renvoie son rsultat. Si je dis la majorit des cas, c'est qu'il y a une exception. Mais laissons cela de ct pour le
moment : le temps de parler des variables statiques n'est pas encore arriv.

Exemple
Prenons un exemple tout bte. Vous voulez faire une fonction qui renvoie le carr d'un nombre pass en paramtre.
Commenons dj par traduire notre fonction en pseudo-code :

1 Entre : nombre
2
3 Carr :

4
5

Multiplier nombre par lui-mme


Retourner nombre

Maintenant, exerons-nous en codant cet algorithme. Je vous encourage le faire avant de regarder la solution, cela
vous fera progresser. Sinon, celle-ci ce trouve ici.
Maintenant que vous avez saisi le principe, nous allons apprendre utiliser nos fonctions, car pour l'instant elles ne
font rien.

Utiliser une fonction


Nous avons dj utilis quelques fonctions, notamment printf et scanf. Pour les utiliser, il suffit de taper le nom de la
fonction suivi des paramtres entre parenthses. Eh bien, pour nos fonctions c'est exactement la mme chose. Prenons
pour illustration la fonction carre vue dans la partie prcdente. Voici le programme complet :

1 #include <stdio.h>
2
3 int carre(int nombre)
4{
return nombre * nombre;
5
6}
7
8 int main(void)
9{
10
int nombre, nombre_au_carre;
11
12
puts("Entrez un nombre : ");
13
scanf("%d", &nombre);
14
15
nombre_au_carre = carre(nombre);
16
printf("Voici le carre de %d : %d\n", nombre, nombre_au_carre);
17
return 0;
18
19 }
On demande l'utilisateur de rentrer un nombre entier. Une fois ceci fait, on appelle la fonction avec cette ligne :

1 nombre_au_carre = carre(nombre);
On dit que nombre est un argument de la fonction carre. Paramtres et arguments sont trs lis ; la diffrence entre les
deux est que les premiers apparaissent lors que la dfinition de la fonction alors que les seconds apparaissent lors de
son l'appel. On demande ensuite attribuer la variable nombre_au_carre la valeur retourne par la fonction carre.
Ainsi, si nombre vaut 4, on appelle la fonction, et celle-ci retournera alors 16 (car 42=16).
Un petit code comment ?

1 #include <stdio.h>
2
3 /* d) le nombre pass en paramtre en c) est rcupr */
4

5 int
6{
7
8
9}
10
11 int
12 {
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27 }

carre(int nombre)
/* e) on fait le calcul et on renvoie la valeur */
return nombre * nombre ;

main(void)
/* a) on dclare nos variables */
int nombre, nombre_au_carre;
puts("Entrez un nombre : ");
/* b) on rcupre la valeur de nombre */
scanf("%d", &nombre);

/* c) on appelle la fonction carre */


nombre_au_carre = carre(nombre);
/* f) nombre_au_carre vaut maintenant la valeur retourne par la fonction c
/* g) on affiche le rsultat */
printf("Voici le carre de %d : %d\n", nombre, nombre_au_carre);
return 0;

a va, vous suivez ? C'est simple : lors de l'appel de la fonction, on lui donne des arguments et le programme s'occupe
du reste. C'est lui qui fera les calculs et qui renverra la valeur afficher.
Sachez qu'il est possible d'optimiser notre code en se passant de cette variable intermdiaire qui stocke le rsultat. En
effet, on peut trs bien appeler la fonction directement dans le printf, comme ceci :

1 #include <stdio.h>
2
3 int carre(int nombre)
4{
return nombre * nombre;
5
6}
7
8 int main(void)
9{
10
int nombre;
11
12
puts("Entrez un nombre :");
13
scanf("%d", &nombre);
14
printf("Voici le carre de %d : %d\n", nombre, carre(nombre));
15
return 0;
16
17 }
Ce code revient au mme que le prcdant, car le deuxime paramtre de printf sera la valeur retourne par la fonction.
Autrement dit, c'est un nombre dans les deux cas, et affichera bien la mme chose l'cran :

1 Entrez un nombre :
2 10
3 Voici le carr de 10 : 100
La fonction main appelle la fonction printf, qui elle-mme appelle la fonction carre. C'est une imbrication de
fonctions. Ainsi, une fonction peut en appeler une autre ; c'est ainsi que tout programme crit en C fonctionne.
Entrainez-vous appeler des fonctions en utilisant toutes les fonctions que nous avons vues au cours de ce chapitre.
Nous verrons d'autres exercices en fin de chapitre.

Appel de fonctions
Il faut aussi prciser une chose importante sur les arguments : si on passe une variable en argument d'une fonction, la
variable en elle-mme ne sera pas modifie. La fonction utilisera la place une copie de la variable ! C'est trs
important, et c'est source de comportements bizarres si on ne fait pas attention. Retenez bien : les arguments d'une
fonction sont copis et c'est cette copie qui est manipule par notre fonction. Considrons l'exemple suivant.

1 #include <stdio.h>
2
3 void fonction(int nombre)
4{
5
++nombre;
printf("Variable nombre dans la fonction : %d\n", nombre);
6
7}
8
9 int main(void)
10 {
11
int nombre = 5;
12
13
fonction(nombre);
printf("Variable nombre dans le main : %d\n", nombre);
14
15
return 0;
16
17 }
1 Variable nombre dans la fonction : 6
2 Variable nombre dans le main : 5
Vous avez vu ? La fonction manipule bien une copie de la variable, car lorsque l'on revient dans la fonction main, la
valeur de la variable est toujours la mme : l'original n'a pas t modifi. Nous verrons nanmoins dans quelques
chapitres comment modifier l'original dans la fonction et non une copie.
On peut lgitimement se demander pourquoi un tel comportement. La raison est assez complexe, mais je peux au
moins vous dire que la raison est fortement lie au matriel de notre ordinateur. La faon dont les fonctions sont
excutes au niveau de notre ordinateur impose que ces arguments soient copis. Pour le moment, ce n'est pas de votre
niveau, mais vous aurez surement la rponse plus tard.

Les prototypes
Avez-vous remarqu qu' chaque fois je mets ma fonction avant la fonction main ? En effet, mettre la fonction aprs
le main provoquera un comportement indtermin. La compilation pourrait trs bien marcher comme elle pourrait
planter. En effet, lorsque la fonction est place avant, le compilateur connait ses paramtres et sa valeur de retour. Du
coup, quand on appelle la fonction, le compilateur vrifie que les arguments qu'on lui donne sont bons. Si au contraire
la fonction est aprs, le compilateur ne connait pas la fonction. Du coup, il lui fixe arbitrairement des caractristiques :

la fonction retourne un int et prend un nombre indtermin de paramtres. Et quand on tente d'appeler la fonction, la
compilation plante, car les arguments ne correspondent pas aux yeux du compilateur.
Heureusement, il existe une sorte de mode d'emploi qui permet d'indiquer toutes les caractristiques d'une fonction au
compilateur. Avec cette indication, on peut placer la fonction o on veut dans le code. Et ce mode d'emploi a un nom :
un prototype. Un prototype se dclare quasiment comme une fonction :

1 type nom_de_la_fonction(arguments);
Voil quoi ressemble un prototype. Placez-le simplement tout en haut de votre fichier et c'est bon ! votre fonction est
utilisable partout dans le code. Essayez donc d'appliquer a la fonction carre :

1 #include <stdio.h>
2
3 int carre(int nombre);
4
5 int main(void)
6{
7
int nombre, nombre_au_carre;
8
9
puts("Entrez un nombre :");
10
scanf("%d", &nombre);
11
12
nombre_au_carre = carre(nombre);
printf("Voici le carre de %d : %d\n", nombre, nombre_au_carre);
13
14
return 0;
15
16 }
17
18 int carre(int nombre)
19 {
20
nombre *= nombre;
return nombre;
21
22 }
Ce code marche parfaitement, vous pouvez tester si vous voulez. La seule chose retenir c'est le point-virgule aprs le
prototype. Il est obligatoire, sinon la compilation plantera.
Si vous mettez toutes vos fonctions avant le main, les prototypes peuvent sembler inutiles, mais je vous encourage
les utiliser. Ds que vous aurez des projets consquents, vous serez obligs de les dclarer.
Avant de conclure sur cette partie, je tiens prciser quelque chose : dans les paramtres du prototype, seuls les types
sont vraiment ncessaires, les identificateurs sont facultatifs. Ainsi le prototype prcdant peut s'crire :

1 int carre(int);
Cependant, cette astuce ne marche que pour les prototypes, n'allez pas le faire pour une fonction (je vous laisse
chercher pourquoi).

Exercices

Comme le dit le vieil adage : "C'est en forgeant qu'on devient forgeron". C'est donc en vous entrainant que vous
devenez petit petit des programmeurs C. Dans cette partie, je vais vous proposer des algorithmes de fonctions, ce
sera vous de les traduire en C. Je mets la solution au cas o vous auriez vraiment du mal, mais je vous encourage le
faire avant de regarder la solution. C'est comme a que vous progresserez le plus.

Afficher un rectangle
Le premier exercice que je vous propose est d'afficher un rectangle. C'est trs simple vous allez voir. Voici l'algorithme
que je vous propose :

1 Entre : longueur, largeur


2
3 Afficher
4
Dclarer deux variables i (longueur) et j (largeur);
5
6
Pour (i = 0 ; i < longueur ; i++)
7
{
8
Pour (j = 0; j < largeur ; j++)
9
{
10
Afficher le symbole '*'
11
}
12
13
Sauter une ligne
14
}
Le code devra afficher ceci dans la console :

1 Donnez la longueur :
25
3 Donnez la largeur :
43
5
6 ***
7 ***
8 ***
9 ***
10 ***

Correction
1 #include <stdio.h>
2
3 /* Prototype avec const qui permet de voir que l'on ne modifie pas la variable
4 void rectangle(const int longueur, const int largeur);
5
6 int main(void)
7{
8
int longueur, largeur;
9
10
puts("Donnez la longueur : ");

11
scanf("%d", &longueur);
12
13
puts("Donnez la largeur : ");
14
scanf("%d", &largeur);
15
16
puts(" ");
17
18
rectangle(longueur, largeur);
return 0;
19
20 }
21
22 void rectangle(const int longueur, const int largeur)
23 {
24
int i, j;
25
for (i = 0; i < longueur; i++)
26
27
{
for (j = 0; j < largeur; j++)
28
29
{
30
putchar('*');
31
}
32
33
puts(" ");
34
}
35 }
Essayez aussi d'afficher le rectangle dans l'autre sens si vous voulez, cela vous servira d'entrainement.

Afficher un triangle
Cette fonction est similaire la prcdente, mais pas tout fait identique, sauf que cette fois on veut afficher un
triangle. Rassurez-vous, l'exercice est plus simple qu'il n'y parait. Pour bien faire cet exercice, on va utiliser d'abord le
pseudo-code pour crire notre algorithme. En voici un tout simple que je vous propose :

1 Entre : nombre_de_lignes
2
3 Afficher
4
Dclarer deux variables i (nombre de lignes) et j (nombre de colonnes);
5
6
Pour (i = 0 ; i < nombre_de_lignes ; i++)
7
{
8
Pour (j = 0; j <= i ; j++)
9
{
10
Afficher le symbole '*'
11
}
12
13
Sauter une ligne
14
}
Ce code, une fois traduit, devrait afficher la sortie suivante dans la console :

1 Donnez un nombre :
25
3
4*
5 **
6 ***
7 ****
8 *****
Bien entendu, la taille du triangle variera en fonction du nombre que l'on donne.

Correction
1 #include <stdio.h>
2
3 void triangle(const int nombre);
4
5 int main(void)
6{
7
int nombre;
8
9
puts("Donnez un nombre : ");
10
scanf("%d", &nombre);
11
12
puts(" ");
13
triangle(nombre);
14
return 0;
15
16 }
17
18 void triangle(const int nombre)
19 {
20
int i, j;
21
for (i = 0; i < nombre; i++)
22
23
{
for (j = 0; j <= i; j++)
24
25
{
26
putchar('*');
27
}
28
29
puts(" ");
30
}
31 }

Coupure
Imaginez le scnario suivant. Vous tes un agent dans une banque et aujourd'hui vous recevez votre client. Celui-ci
vous demande de lui livrer une somme avec la coupure qu'il vous a indique. Par exemple, il vous dit qu'il souhaite
rcuprer 300 000 uniquement en billets de 500 et de 200. Dans ce cas vous lui donnerez le plus de billets de 500
possible puis vous continuerez avec des billets de 200.

Ici, la coupure sera la suivante :

Des billets de 100.


Des billets de 50.
Des billets de 20.
Des billets de 10.
Des pices de 2.
Des pices de 1.
Votre client vous indique la somme qu'il souhaite et vous la lui fournissez en tenant compte de la coupure spcifique.

1 Quelle somme voulez-vous ? 285


2 2 billet(s) de 100.
3 1 billet(s) de 50.
4 1 billet(s) de 20.
5 1 billet(s) de 10.
6 2 pice(s) de 2.
7 1 pice(s) de 1.
Exemple de prototype pour la fonction :

1 void coupure (const int somme);


Et exemple de pseudo-code :

1 Entre : somme
2
3 Afficher
4
Dclarer deux variables n
5
6
Si n /= 100 > 0
7
{
8
Afficher "n billet(s)
9
}
10
11
tmp -= n * 100;
12
n = tmp / 50;
13
14
Si (tmp / 50) > 0
15
{
16
Afficher "n billet(s)
17
}
18
19
tmp -= n * 50;
20
n = tmp / 20;
21
22
Si (tmp / 20) > 0
23
{
24
Afficher "n billet(s)
25
}
26

(nombre de billet) = somme et tmp (variable tempo

de 100."

de 50."

de 20."

27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

tmp -= n * 20;
n = tmp / 10;
Si (tmp / 10) > 0
{
Afficher "n billet(s) de 10."
}
tmp -= n * 10;
n = tmp / 2;
Si (tmp / 2) > 0
{
Afficher "n piece(s) de 2."
}
Si ((tmp -= n * 2) > 0)
{
Afficher "tmp piece(s) de 1."
}

Correction
1 #include <stdio.h>
2
3 void coupure(const int somme)
4{
5
int n = somme, tmp = somme;
6
if((n /= 100) > 0)
7
8
{
printf("%d billet(s) de 100.\n", n);
9
10
}
11
12
tmp -= n * 100;
13
n = tmp / 50;
if((tmp / 50) > 0)
14
15
{
printf("%d billet(s) de 50.\n", n);
16
17
}
18
19
tmp -= n * 50;
20
n = tmp / 20;
if((tmp / 20) > 0)
21
22
{
printf("%d billet(s) de 20.\n", n);
23
24
}
25
26
tmp -= n * 20;

27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44 }
45
46 int
47 {
48
49
50
51
52
53
54 }

n = tmp / 10;
if((tmp / 10) > 0)
{
printf("%d billet(s) de 10.\n", n);
}
tmp -= n * 10;
n = tmp / 2;
if((tmp / 2) > 0)
{
printf("%d billet(s) de 2.\n", n);
}
if((tmp -= n * 2) > 0)
{
printf("%d piece(s) de 1.\n", tmp);
}

main(void)
int somme;
scanf("%d", &somme);
coupure(somme);
return 0;