Seance 3- Programmation en langage C

Programmation en langage C
Fahad R. Golra
Faculté des Sciences et Technologies
Université de Lorraine
Séance 3 – Fonctions

2 13/10/2017
Programmation Structurée
Programmation en langage C, Université de Lorraine
• La programme est écrit dans un manière structurée.
• Découper un programme en parties isolées
• Remplacer une partie qui se répète
• Les fonctions permettent d’écrire un programme de manière
modulaire.
• Un programme C sera constitué donc de plusieurs modules
(fonctions) qui pourront être appelés autant de fois que
nécessaire avec un paramétrage souvent différent.
• Chaque module pourra lui aussi être décomposé en sous-module.

3 13/10/2017
Exemple de fonction
• On vient de définir une
fonction dont le nom est
« carre »
• qui a un paramètre x de
type int
• qui retourne un
nombre entier (carré de
x) de type int
• La valeur retourné pourra
bien entendu être affecté à
une variable.
# include <stdio.h>
int carre(int);
int main(void)
{
int n, n2, n3;
printf("Entrez un nombre ");
scanf("%d", &n);
n2 = carre(n);
printf("Carre de %d = %d", n, n2);
n3 = carre(n2);
printf("Carre de %d = %d", n2, n3);
return 0;
}
int carre (int x)
{
int res;
res = x * x;
return res;
}

4 13/10/2017
Décomposition en modules
# include <stdio.h>
int carre(int);
int main(void)
{
int n, n2, n3;
scanf("%d", &n);
n2 = carre(n);
n3 = carre(n2);
return 0;
}
int carre (int x)
{
int res;
res = x * x;
return res;
}
Fonction main
Fonction carre
• Découper un programme en
parties isolées

5 13/10/2017
Gérer la répétition
# include <stdio.h>
int carre(int);
int main(void)
{
int n, n2, n3;
scanf("%d", &n);
n2 = carre(n);
n3 = carre(n2);
return 0;
}
int carre (int x)
{
int res;
res = x * x;
return res;
}
• Remplacer une partie qui se
répète
• Le seul type de sous-
programme qui existe en C
est la fonction

6 13/10/2017
Syntaxe générale
• Dans cette déclaration type_R
est le type de retour de la
valeur calculée par la
fonction. On dit aussi par
abus de langage qu’il s’agit du
type de la fonction.
• type1, type2 sont les types
des variables nom1 et nom2
etc. passées en paramètre de
la fonction. On dit aussi que
ce sont les arguments de la
fonction.
type nomDeFonction( liste de paramètre(s))
{
déclarations locales si nécessaire
Instructions
….
retour du résultat (avec return)
}
type_R nom_fct ( type1 nom1, type2 nom2 ….)
{
Instructions
….
return valeur;
}

7 13/10/2017
Syntaxe générale
• Dans cette déclaration type_R
est le type de retour de la
valeur calculée par la
fonction. On dit aussi par
abus de langage qu’il s’agit du
type de la fonction.
• type1, type2 sont les types
des variables nom1 et nom2
etc. passées en paramètre de
la fonction. On dit aussi que
ce sont les arguments de la
fonction.
type nomDeFonction( liste de paramètre(s))
{
déclarations locales si nécessaire
Instructions
….
retour du résultat (avec return)
}
type_R nom_fct ( type1 nom1, type2 nom2 ….)
{
Instructions
….
return valeur;
}

8 13/10/2017
Exemple de fonction
# include <stdio.h>
int carre(int);
int main(void)
{
int n, n2, n3;
scanf("%d", &n);
n2 = carre(n);
n3 = carre(n2);
return 0;
}
int carre (int x)
{
int res;
res = x * x;
return res;
}
• Ecrire un programme en
utilisant les fonctions
• Appel à fonction
• Fournir le nom de la
fonction et les arguments
(données)
• La fonction effectue des
opérations ou des
manipulations
• La fonction renvoie les
résultats

9 13/10/2017
Exemple de fonction
# include <stdio.h>
int carre(int);
int main(void)
{
int n, n2, n3;
scanf("%d", &n);
n2 = carre(n);
n3 = carre(n2);
return 0;
}
int carre (int x)
{
int res;
res = x * x;
return res;
}
Prototype de fonction
type_r nom_funct (type_p, …);
Appel à fonction
nom_funct (valeur p, …);
Fonction retourne un valeur int
Fonction prends un valeur int
en parametre
Fonction retourne la valeur
Déclaration locale

10 13/10/2017
Portée des fonctions
• Les variables locales et les
copies locales des paramètres
n’existent plus lorsque
l’exécution de la fonction est
terminée
# include <stdio.h>
int carre(int);
int main(void)
{
int n, n2;
scanf("%d", &n);
n2 = carre(n);
printf("%d", res);//res n'exist plus
return 0;
}
int carre (int x)
{
int res;
n2 = x * x;//n2 n'est pas accessible
res = x * x;
return res;
}
Erreur
Erreur

11 13/10/2017
Return
• L’appel de la fonction « vaut » le résultat retourné
• La valeur retournée est celle placée à droite de l’instruction
return qui est exécutée
par ex: return 0; /* retourne la valeur 0 (faux) */
• Une fonction ne peut retourner qu’une seule valeur avec return
• L’exécution du return provoque la fin de la fonction
int carre (int x)
{
int res;
res = x * x;
return res;
}
La valeur retournée

12 13/10/2017
Fonction void
• Ne retourne pas de valeur
• L’utilisation de return est
possible mais sans placer
de valeur. Cette instruction
va terminer l’exécution de la
fonction
• Utile lorsque l’on veut faire
un traitement qui ne produit
pas de nouvelle valeur
• ex : Affichage, trie. etc.
# include <stdio.h>
void ligne(int);
int main(void)
{
ligne(30);
printf("Premiere phrase n");
ligne(10);
printf("Deuxieme phrase n");
ligne(30);
return 0;
}
void ligne(int x)
{
int i = 0;
for (i = 0; i <= x; i++)
printf("-");
printf("n");
return;
}

13 13/10/2017
Exemple : fonction factorielle
• En mathématiques, la factorielle d'un entier naturel n est le
produit des nombres entiers strictement positifs inférieurs ou
égaux à n.
• La fonction factorielle « fact » peut être écrite de manière
récursive, i.e. la fonction s’appelle elle-même.
fact(n) =1 * 2 * 3 …. * (n-1) * n
fact(n) = n * (n-1) * …. 3 * 2 * 1
fact(n) = n * fact(n-1)

14 13/10/2017
Récursion
• Une fonction peut faire référence à elle-même et s'appeler elle-
même.
fact(4)
return 1
fact(3)4 *return
fact(2)3 *return
fact(1)2 *return
appel
résultat

15 13/10/2017
Exemple : fonction factorielle
• La fonction factorielle « fact »
peut être écrite de manière
itérative avec une boucle ou
de manière récursive, i.e. la
fonction s’appelle elle-même.
• Pour ce dernier cas on utilise
la propriété de récurrence de
fact :
fact(n)=n*fact(n-1)
# include <stdio.h>
int facti(int);
int factr(int);
int main(void)
{
int x, f;
scanf("%d", &x);
f = facti(x);
printf("Fact iterative = %d", f);
f = factr(x);
printf("Fact recursive = %d", f);
return 0;
}
int facti (int n)
{
int i, res = 1;
for (i = 1; i <= n; i++)
res = res * i;
return res;
}
int factr (int n)
{
if (n <= 1)
return 1;
else return (n * factr(n - 1));
}

16 13/10/2017
Permutation
• Les variables x et y ne sont pas permutées. Pourquoi ?
# include <stdio.h>
void permute(int, int);
int main(void)
{
int x = 3, y = 4;
permute (x, y);
printf("x = %dn", x);
printf("y = %dn", y);
return 0;
}
void permute(int a, int b)
{
int temp;
temp = a;
a = b;
b = temp;
}

17 13/10/2017
Permutation
# include <stdio.h>
int main(void)
{
int x = 3, y = 4;
permute (x, y);
return 0;
}
{
int temp;
temp = a;
a = b;
b = temp;
}
• Par défaut, seul une copie de la
valeur est passée en paramètre
• a = 3 (copie de la valeur de x)
• b = 4 (copie de la valeur de y)
• Permutation a et b, donc
• a = 4
• b = 3
• Fonction retourne aucune
valeur
• Aucun effet sur x et y

18 13/10/2017
Permutation – Passage par valeur
# include <stdio.h>
int main(void)
{
int x = 3, y = 4;
permute (x, y);
return 0;
}
{
int temp;
temp = a;
a = b;
b = temp;
}
a 3
b 4
Copie
x 3
y 4

19 13/10/2017
Permutation – Passage par référence
• Si l'on veut qu'une fonction modifie un paramètre, on ne passe
pas la variable mais l'adresse de la variable.
# include <stdio.h>
void permute(int*, int*);
int main(void)
{
int x = 3, y = 4;
permute (&x, &y);
return 0;
}
void permute(int *a, int *b)
{
int temp;
temp = *a;
*a = *b;
*b = temp;
}
• On a passé la copie de
l'adresse de la variable. Dans la
fonction on va chercher la
variable par son adresse.

20 13/10/2017
Permutation – Passage par référence
• Si l'on veut qu'une fonction modifie un paramètre, on ne passe
pas la variable mais l'adresse de la variable.
# include <stdio.h>
int main(void)
{
int x = 3, y = 4;
permute (&x, &y);
return 0;
}
{
int temp;
temp = *a;
*a = *b;
*b = temp;
}
*a &x
*b &y
x 3
y 4
3
4
x la valeur de la variable
&x l'adresse de la variable
*a la valeur de la variable qui
se trouve à l'adresse
contenue dans a

21 13/10/2017
Permutation
# include <stdio.h>
int main(void)
{
int x = 3, y = 4;
permute (&x, &y);
return 0;
}
{
int temp;
temp = *a;
*a = *b;
*b = temp;
}
# include <stdio.h>
int main(void)
{
int x = 3, y = 4;
permute (x, y);
return 0;
}
{
int temp;
temp = a;
a = b;
b = temp;
}
Passage par référence Passage par valeur

22 13/10/2017
Retourner plusieurs résultats
• De manière générale une fonction ne retourne qu’une valeur
calculée à l’aide de l’instruction return. Cette valeur doit avoir
bien entendu le même type que celui de la fonction.
• Toutefois on peut contourner cette règle, en définissant des
paramètres formels de type pointeur et passage par référence.
void calcule ( int *a, int *b)
{
int res1, res2;
res1 = (*a) + (*a);
res2 = (*b) + (*b) + (*b);
*a = res1;
*b = res2;
}

23 13/10/2017
Passage de tableau en paramètres
#include <stdio.h>
float moyen(float tab[]);
int main(void)
{
float n;
float tab[] = { 23.4, 55, 22.6, 40.5};
n = moyen(tab); /* Seul le nom
de tableau est passé en paramètre*/
printf("Moyen = %.2f", n);
return 0;
}
float moyen(float tab[])
{
int i;
float res, somme = 0.0;
for (i = 0; i < 4; i++)
somme += tab[i];
res = (somme / 4);
return res;
}
• Pour passer un tableau à
une dimension en
paramètre, on passe
seulement le nom du
tableau
• Rappelez-vous: le nom d'un
tableau est un pointeur
vers le premier élément du
tableau.
• Ce programme
fonctionnera, mais la taille
du tableau n'est pas claire
pour le lecteur.

24 13/10/2017
#include <stdio.h>
#define dimension 4
float moyen(float tab[]);
int main(void)
{
float n;
float tab[] = { 23.4, 55, 22.6, 40.5};
n = moyen(tab); /* Seul le nom
de tableau est passé en paramètre*/
return 0;
}
float moyen(float tab[dimension])
{
int i;
for (i = 0; i < dimension; i++)
somme += tab[i];
res = (somme / dimension);
return res;
}
• Comme le nom d'un
tableau est un pointeur
vers le premier élément du
tableau. On peut aussi
déclaré le fonction moyen :
float moyen(float *tab)
{
…
}

25 13/10/2017
• On peut également passer
la taille du tableau en
paramètre.
• De cette façon, la fonction
peut être réutilisée pour
des tableaux de différentes
tailles.
#include <stdio.h>
float moyen(float tab[], int taille);
int main(void)
{
float n;
float tab[] = { 23.4, 55, 22.6, 40.5};
n = moyen(tab, 4); /* passer la taille
en parametre*/
return 0;
}
float moyen(float tab[], int taille)
{
int i;
for (i = 0; i < taille; i++)
somme += tab[i];
res = (somme / taille);
return res;
}

26 13/10/2017
Passage de tableau multidimensionnelle
#include <stdio.h>
#define lig 3
#define col 3
int question2 ( int t[lig][col]);
int main (void)
{
int somme;
int tab[lig][col]={{1,2,3},{4,5,6},{7,8,9}};
somme = question2(tab);
printf("Somme diagonale = %dn", somme );
return 0;
}
int question2 ( int t[lig][col])
{
int i, j, res;
for (i = 0, res = 0; i < lig; i++)
for (j = 0; j < col; j++)
if (i == j)
res += t[i][j];
return res;
}
t[][col]
aussi possible

Seance 3- Programmation en langage C

Contenu connexe

Tendances

Similaire à Seance 3- Programmation en langage C

Plus de Fahad Golra

Dernier

Seance 3- Programmation en langage C