Vous êtes sur la page 1sur 46

Dr Pélagie HOUNGUE

 Fonctions
 Introduction
 Structure d’une fonction
 Appel d’une fonction
 Passage par valeur
 Passage par adresse
 Variables globales et variables locales
 Le mot clé static
 Fonctions récursives
 Programmation multifichiers
 Tableaux
 Les types complexes
 Déclaration
 Initialisation
 Accès
 Quelques méthodes de tri

Langage C Dr Pélagie HOUNGUE 2


 Un programme C bien conçu, contient en
général de nombreuses petites fonctions.
 on peut découper un programme en
plusieurs fonctions
 mais une seule fonction est obligatoire
 la fonction principale
 Chaque fonction contient une série
d'instructions qui seront exécutées à chaque
fois que cette fonction sera appelée.

Langage C Dr Pélagie HOUNGUE 3


 Une fonction est construite à partir
 d’une interface constituée du type de retour et du nom
de la fonction, suivis par les types et les noms de ses
paramètres
 d’un bloc, appelé aussi corps de la fonction
 L’interface d’une fonction est suivie des accolades
délimitant le corps de cette fonction.
 La syntaxe de la définition d'une fonction est la
suivante:

 Type_retour nomFonction(type1 param1, ..., typeN paramN)


{
instruction 1 ;
...
instruction N ;
}

Langage C Dr Pélagie HOUNGUE 4


 Corps de la fonction
 Le corps de la fonction peut débuter par une série de
définitions de variables.
 Ces variables sont appelées variables locales.
 Chaque appel de la fonction crée de nouvelles instances
des variables locales.
 Exemple
 double moyenne (double a, double b)
{
return (a + b) / 2;
}
 Le mot-clé return est suivi d'une expression.
 La valeur de cette expression sera le résultat de la
fonction.
 Dernière instruction d'une fonction  instruction
return
Langage C Dr Pélagie HOUNGUE 5
 Appel d’une fonction
 nom de la fonction, suivi de la liste des valeurs à donner aux
paramètres entre parenthèses.
 c = moyenne(30.5, 7.5);
 Si la fonction ne retourne rien, le type retourné est void.
 void AffMessage(void) {
printf("Voici un message\n");
}
 Paramètres formels d'une fonction
 Paramètres définis dans l’interface de la fonction
 pas de limite au nombre de paramètres formels
 le type d'un paramètre formel peut être soit un type de base soit un
type complexe comme un tableau par exemple
 Paramètres effectifs
 Ce sont les variables utilisées pour appeler la fonction
 Différents types d’appel
 Passage par valeur
 Passage par adresse

Langage C Dr Pélagie HOUNGUE 6


 Les paramètres formels peuvent être considérés
comme des variables locales à la fonction.
 Lors de l'appel de la fonction, la valeur de
chaque paramètre effectif est recopiée dans un
nouvel espace mémoire réservé.
 Les valeurs utilisées lors de l'appel ne seront
absolument pas modifiées.

Langage C Dr Pélagie HOUNGUE 7


 Exemple
#include <stdio.h>
int add(int a, int b)
{
int c;
c = a + b;
return c;
}

int main()
{
int i,j,k;
i=4;
j=12;
/* on passe les valeurs de i et j */
k=add(i,j);
printf(“La somme donne : %d”,k) ;
}
Langage C Dr Pélagie HOUNGUE 8
 Le passage des paramètres par valeur ne permet pas
de modifier une variable de la fonction appelante.
 Pour modifier la valeur d’un paramètre effectif
 Utiliser son adresse en mémoire (c'est-à-dire un pointeur
sur cette variable).

Langage C Dr Pélagie HOUNGUE 9


 Exemple 1
#include <stdio.h>

void add(int a, int b, int * c)


{
*c = a + b;
}

int main()
{
int i,j,k;

/* on passe les valeurs de i et j comme 1er et 2ième


paramètres et on passe l’adresse de k comme 3ième
paramètre*/
i=4; j=12;
add(i,j,&k);
printf(“%d”,k) ;
return 0 ;
}
Langage C Dr Pélagie HOUNGUE 10
 Exemple 2
#include <stdio.h>
void permutation(int *nb1, int *nb2)
{
int temp;
temp= *nb1;
*nb1 = *nb2;
*nb2 = temp;
}

int main(void) {
int nombre1 = 10, nombre2 = 20;
printf("nombre 1 = %d et nombre 2 = %d\n", nombre1, nombre2);
permutation(&nombre1, &nombre2);
printf("nombre 1 = %d et nombre 2 = %d\n", nombre1, nombre2);
return 0;
}

Langage C Dr Pélagie HOUNGUE 11


 Variable globale
 Une variable globale est une variable qui est
définie en dehors de toute fonction.
 Une variable globale déclarée au début d’un
fichier source peut être utilisée dans toutes les
fonctions du fichier.
 La variable n’existe qu’en un seul exemplaire et
la modification de la variable globale dans une
fonction change la valeur de cette variable dans
les autres fonctions.

Langage C Dr Pélagie HOUNGUE 12


 EXEMPLE
#include <stdio.h>

int x ; /* déclaration de la variable en dehors de toute fonction */

void ModifieGlobale(void)
{
x = x+1;
}

void AfficheGlobale(void)
{
printf("La valeur de la variable globale est : %d\n", x);
}

int main(void)
{
x = 1;
ModifieGlobale();
AfficheGlobale(); /* affiche 2 */
x++;
printf("La nouvelle valeur de la variable globale est : %d\n", x); /*affiche 3*/
return 0;
}

Langage C Dr Pélagie HOUNGUE 13


 Variable locale
 C’est une variable définie à l’intérieur d’une fonction
(ou d'un bloc d'instructions) du programme.
 Elle n’est visible et accessible qu’à l’intérieur de
cette fonction.
 Par défaut, les variables locales sont temporaires.
 Les variables locales à une fonction ont une durée de vie
limitée à une seule exécution de cette fonction. Leurs
valeurs ne sont pas conservées d'un appel au suivant.
 Par ailleurs, les variables locales n'ont en particulier
aucun lien avec des variables globales du même nom.

Langage C Dr Pélagie HOUNGUE 14


 Exemple
#include <stdio.h>
void fonctionNew(void)
{
int x = 1 ; /*x est locale*/
x = x+4;
printf("La valeur de x dans fonction est : %d\n", x); /*x = 5*/
}
int main(void)
{
int x= 1; /*x est locale*/
x = x + 6;
printf("La valeur de x dans fonction principale est : %d\n", x);
/*x = 7*/
fonctionNew();
x++;
printf("La valeur de x dans fonction principale est : %d\n", x);
/*x=8*/
return 0;
}
Langage C Dr Pélagie HOUNGUE 15
 Lorsqu'on sort d'une fonction, on perd la
valeur des variables locales, à l'appel suivant
 Impossible d'utiliser la valeur de la variable
locale de l'appel précédent.
 Solution
 En utilisant le mot clé static devant le nom de la
variable locale, la valeur de la variable locale est
conservée d'un appel à l'autre (i.e. la mémoire
reste allouée).
 Mais la variable reste locale
 elle n'est pas visible en dehors de la fonction.

Langage C Dr Pélagie HOUNGUE 16


#include <stdio.h>
void f()
{
static int i = 0; /* i ne sera initialisé à 0 qu'au premier appel de f */
int j = 0; /* j sera initialisé à chaque fois */;
i++;
j++;
printf("i vaut %d et j vaut %d.\n", i, j);
}

int main() {
f();
f();
f();
return 0;
}

Langage C Dr Pélagie HOUNGUE 17


 Le langage C autorise la récursivité des appels
de fonctions. Celle-ci peut prendre deux
aspects :
 récursivité directe : une fonction comporte, dans sa
définition, au moins un appel à elle-même.
 récursivité croisée : l’appel d’une fonction entraîne
celui d’une autre fonction qui, à son tour, appelle la
fonction initiale (le cycle pouvant d’ailleurs faire
intervenir plus de deux fonctions).
int fac(int n)
{
if (n>1)
return (fac(n-1)*n) ;
else
return(1) ;
}
Langage C Dr Pélagie HOUNGUE 18
 Programmes informatiques longs
 Il devient pénible de mettre tout le code source
dans un seul fichier
 Solution
 Créer plusieurs fichiers .c contenant chacun une ou
plusieurs fonctions
 Les fonctions définies dans certains fichiers (par
exemple le main) utilisent des fonctions qui sont
définies dans d’autres fichiers
 Nécessaire de créer des fichiers d’en-tête
 contiennent les définitions des types (structures,
etc.), et les prototypes de fonctions qui concernent
plusieurs fichiers
 Les fichiers d’en-tête, ou header files, ont une
extension .h. Il faut les inclure dans les fichiers .c
par une directive #include

Langage C Dr Pélagie HOUNGUE 19


 Exemple : programme qui affiche la somme
et le produit de deux entiers
/*compilSepare.c ; contient la fonction /*somme.c ; contient les
principale*/ fonctions*/
#include <stdio.h> int somme(int a, int b)
#include "entete.h" {
int main() return a + b;
{ }
int a = 5, b = 9;
int produit(int a, int b)
printf("%d + %d = %d\n", a, b, {
somme(a, b)); int prod = 0;
printf("%d * %d = %d\n", a, b,
produit(a, b)); while (b-- > 0)
prod += a;
return 0;
} return prod;
}
Langage C Dr Pélagie HOUNGUE 20
/*fichier entete.h ; contient les prototypes des fonctions*/
int somme(int a, int b);
int produit(int a, int b);

Langage C Dr Pélagie HOUNGUE 21


Ecrire un programme en C qui affiche la
somme des n premiers nombres premiers. On
fera usage de deux fonctions. La première
fonction nommée somme_premier prend en
argument un nombre entier n et retourne la
somme des n premiers nombres premiers. La
deuxième fonction nommée si_premier prend
en argument un nombre entier et retourne 1
si le nombre est premier et 0 sinon. La
première fonction fera appel à la deuxième.

Langage C Dr Pélagie HOUNGUE 22


 Ecrire un programme qui fait la somme des n
premiers nombres impairs, n étant lu au
clavier et passé à une fonction.

Langage C Dr Pélagie HOUNGUE 23


 Écrire une fonction qui reçoit en arguments 2
nombres flottants et un caractère, et qui fournit
un résultat correspondant à l’une des 4
opérations appliquées à ses deux premiers
arguments, en fonction de la valeur du dernier, à
savoir : addition pour le caractère +,
soustraction pour -, multiplication pour * et
division pour / (tout autre caractère que l’un
des 4 cités sera interprété comme une addition).
 Écrire un petit programme principal utilisant
cette fonction pour effectuer une opération
demandée par l’utilisateur sur 2 nombres fournis
au clavier.

Langage C Dr Pélagie HOUNGUE 24


 Ecrire une fonction récursive permettant de
calculer la suite de Fibonacci. La fonction
prend un entier positif n et retourne le
résultat du calcul de la suite.
 La suite de Fibonacci est définie par
récurrence par :
 u0 = 0 ; u1 = 1
 un = un−1 + un−2 pour n ≥ 2

Langage C Dr Pélagie HOUNGUE 25


 Ecrire un programme c comportant :
 1. la déclaration de 3 variables globales entières
heures, minutes, secondes ;
 2. une fonction print_heure qui ne prend rien comme
paramètre et imprimera le message :
 Il est ... heure(s) ... minute(s) ... seconde(s)
 3. une fonction set_heure qui admettra trois
paramètres de type entiers h, m, s, dont elle
affectera les valeurs respectivement à heures,
minutes et secondes ;
 4. une fonction tick qui ne prend rien comme
paramètre et qui incrémentera l'heure de une (1)
seconde ;
 5. la fonction main sera un jeu d'essai des fonctions
précédentes.
Langage C Dr Pélagie HOUNGUE 26
Les tableaux

Langage C Dr Pélagie HOUNGUE 27


 Lestypes plus complexes que sont les tableaux,
les pointeurs et les structures, ….
 Les tableaux sont constitués de valeurs d’un même
type rangées successivement en mémoire (dans des
emplacements de même taille).
 Les structures sont constituées de valeurs également
contiguës, mais de types et de tailles possiblement
différentes
 Les variables de type pointeur, permettent
d’accéder à des valeurs d’un type donné quelconque
à partir d’une adresse qui sera leur valeur initiale.

Langage C Dr Pélagie HOUNGUE 28


 Il est possible d'utiliser des tableaux de
valeurs.
 Tous les éléments d'un tableau sont
obligatoirement du même type.
 Pour un tableau de taille N, l'indice du
premier élément est 0 et celui du dernier est
(N -1).
 Tableaux de dimension 2 ou plus.

Langage C Dr Pélagie HOUNGUE 29


 Déclaration
 Type des éléments, nom du tableau et enfin la taille du
tableau entre crochets
 Dans l'exemple suivant, nous définissons deux tableaux de
100 éléments, l'un contenant des réels, l'autre des entiers. Le
dernier tableau définit une matrice 3x3 d’éléments de type
double.
 float VecteurA[100];
int VecteurB[100];
double MatriceTroisTrois[3][3];
 Initialisation
 float tab2[]={1.2,3.14,2.0}; // 3 éléments initialisés
 char tab3[5]={’a’,’b’,’c’}; // 5 éléments, 3 initialisés
 double MatriceTroisTrois[3][3]= {{ 1, 0, 0 },
{ 0, 1, 0 },
{ 0, 0, 1 }};

Langage C Dr Pélagie HOUNGUE 30


 Cas particulier
 Initialisation d'un tableau de caractères pour
laquelle on peut utiliser une chaîne de
caractères.
 char Str[20] = {'B', 'o', 'n', 'j', 'o', 'u', 'r'};
char Str[20] = "Bonjour";

Langage C Dr Pélagie HOUNGUE 31


 opérateur []
 La valeur mise entre crochets peut être un calcul.
 Dans l'exemple suivant, on stocke à l’emplacement du
troisième élément de Tab, la valeur du ième élément :
 int i = 5;
 int Tab[10] = {1, 5, 8, 7, 5, 6, 12, 15, 7, 10};
 Tab[2] = Tab[i - 1];

Langage C Dr Pélagie HOUNGUE 32


 Exercice 1
 Ecrire un programme C qui permet de calculer la
moyenne des éléments d’un tableau de type
float. Les éléments du tableau seront lus au
clavier. La taille du tableau est fixée à 10.
 Exercice 2
 Ecrire un programme C qui donne le plus grand
élément d’un tableau de 10 entiers. Les
éléments du tableau seront lus au clavier.

Langage C Dr Pélagie HOUNGUE 33


 Définition
 Un tableau à deux dimensions T est comme un
tableau (uni-dimensionnel) de dimension L dont
chaque composante est un tableau (uni-
dimensionnel) de dimension C.

Langage C Dr Pélagie HOUNGUE 34


 Initialisation
int ELEMENTS[10][20] = {{45, 34, ... , 50, 48},
{39, 24, ... , 49, 45},
... ... ...
{40, 40, ... , 54, 44}};

Langage C Dr Pélagie HOUNGUE 35


 Tableau à une dimension
 Premier cas : Taille fixe
/*Définition de la fonction*/
void test (int tab[20])
{
int i ;
for (i=0 ; i<20 ; i++) tab[i] =1 ;
}

/*Prototypes possibles*/
void test (int tab[20]); ou
void test (int * tab); ou
void test (int tab[]);

/*Appel de la fonction*/
int t1[20];
test(t1) ;
Langage C Dr Pélagie HOUNGUE 36
 Tableau à une dimension
 Deuxième cas : Nombre d’éléments variable en
argument /*Définition*/
int somme (int tab[], int nbre)
{ int s = 0, i ;
for (i=0 ; i<nbre ; i++)
s += tab[i] ;
return (s) ;
}
/*appels*/
int tab1[10], tab2[15];
int s1, s2 ;
s1 = somme(tab1, 10) ;
s2 = somme(tab2, 15) ;
/*Prototypes*/
int somme (int tab[],int nb);
int somme (int *tab,int nb);
Langage C Dr Pélagie HOUNGUE 37
 Tableau à 2 dimensions
 Premier cas : Taille fixe
void remplir (int t[3][4]) /*void remplir (int t[][4])*/
{
int i, j ;
for (i=0 ; i<3 ; i++)
for (j=0 ; j<4 ; j++)
t[i][j] = 0 ;
}

/*prototypes*/
void remplir (int t[][4]);
void remplir (int t[3][4]);

/*Appel*/
int tab[3][4] ;
remplir(tab) ;
Langage C Dr Pélagie HOUNGUE 38
 Tableau à 2 dimensions
Deuxième cas : Nombre de lignes variable en
Exemple :
argument
int som (int a[][4], int n); /*n représente le nombre de lignes*/
int main() {
int t1[3][4]={1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
int t2[4][4]={1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
printf ("Somme elements tableau 1 : %d", som(t1,3));
printf ("Somme elements tableau 2 : %d", som(t2,4));
return 0;
}

int som(int a[][4], int n)


{
int som=0,i,j;
for (i=0; i<n; i++)
for (j=0; j<4; j++)
som=som+a[i][j];
return som;
Langage C Dr Pélagie HOUNGUE 39
}
 Le tri des éléments d’un tableau
 Il existe de nombreuses méthodes pour trier par
ordre croissant les éléments d’un tableau.
 TRI PAR SÉLECTION
 Principe du tri par sélection
 Considérons un tableau T de n nombres.
 Le principe du tri par sélection est le suivant.
 On sélectionne le maximum (le plus grand) de tous
les éléments, et on le place en dernière position n-1
par un échange. Il ne reste plus qu’à trier les n-1
premiers éléments, pour lesquels on réitère le
procédé.
 On peut rechercher également le plus petit élément
qu’on met au début du tableau et ainsi de suite

Langage C Dr Pélagie HOUNGUE 40


 Exemple
 TRI PAR SÉLECTION
1

Langage C Dr Pélagie HOUNGUE 41


 TRI PAR INSERTION
 Principe du tri par insertion
 Le principe du tri par insertion est le suivant :
 On trie d’abord les deux premiers éléments, puis on
insère le 3ème à sa place pour faire une liste triée
de 3 éléments.
 Puis on insère le 4ème élément dans la liste triée.
La liste triée grossit jusqu’à contenir les n éléments.

Langage C Dr Pélagie HOUNGUE 42


 Exemple
 TRI PAR INSERTION
1

Langage C Dr Pélagie HOUNGUE 43


 Exercice 1.- (Recherche)
 Ecrire un programme C qui recherche un nombre
donné dans un tableau d’entiers et affiche le
nombre de fois que l’élément apparait.
 Exercice 2.- (Produit scalaire)
 Ecrire un programme C qui affiche le produit
scalaire de deux tableaux à une dimension. Chaque
tableau contient 10 éléments de type entier et ses
éléments sont lus au clavier.

Langage C Dr Pélagie HOUNGUE 44


 Exercice 3.- (Nombre d’éléments pairs et
impairs d’un tableau)
 Ecrire un programme C qui lit un tableau
d’entiers positifs. La taille du tableau est fixée
à 20 éléments. Ensuite, le programme doit
afficher parmi les éléments du tableau, ceux
qui sont des nombres pairs et ceux qui sont des
nombres impairs.
 Exercice 4.- (Inverse d’un tableau)
 Ecrire un programme C qui range les éléments
d'un tableau A d’entiers, dans l'ordre inverse et
affiche le résultat.

Langage C Dr Pélagie HOUNGUE 45


 Exercice 5.- (tri des éléments d’un tableau)
 Ecrire un programme qui effectue le tri par
sélection d’un tableau de 10 entiers lu au
clavier.
 Ecrire un programme qui effectue le tri par
insertion d’un tableau de 10 entiers lu au
clavier.

Langage C Dr Pélagie HOUNGUE 46

Vous aimerez peut-être aussi