Cours C Partie 5

Ecole supérieure de Technologie
Département de Génie Electrique
Partie 5
FONCTIONS
Khalid SBAI – Cours D’Informatique

11/09/2021
III. FONCTIONS
Introduction
Enoncé d’un problème
Analyse
Données résultats
Formulation de l’Algorithme
Sous- … Sous- … Sous-

programme_1 programme_k programme_n
Chacun réalise une tâche bien définie

11/09/2021
III. FONCTIONS
Définition: On appelle fonction un sous-programme qui permet
d’exécuter un ensemble d'instructions par simple appel de la
fonction dans le corps du programme principal.
Structuration d’un programme

Un programme C est constitué d'un ensemble de fonctions toutes
accessibles à partir du programme principal main().
En programmation structurée, le programme est divisé en
fonctions qui réalisent chacune une tâche bien définie. Ceci
facilite l'organisation et la mise au point du programme.
Un programmeur professionnel utilise des bibliothèques de
fonctions pour accélérer le développement de son application.
11/09/2021
III. FONCTIONS
Une fonction vue du processeur
C'est un code exécutable à une adresse en mémoire terminé par

une instruction de retour
A l'appel de la fonction, le μ-processeur exécute le code à partir

de l'adresse de la fonction et l'instruction retour le fait revenir à
l'instruction suivant l'appel.
Des données peuvent être transmises à la fonction en

paramètres. Lors du retour une valeur peut être récupérée.

11/09/2021
III. FONCTIONS
Définition
Une fonction est donc un code (programme) exécutable à une
adresse en mémoire terminé par une instruction de retour.
#include <stdio.h> Appel de la fonction
void main()
{ int a=3, b=8, c;
int somme(int a1, int b1); Exécution du code
c = somme(a, b); à partir de l'adresse
printf("Somme de a et b : %d\n", c); de la fonction.
}
int somme(int a1, int b1) Instruction retour le
{ int c1;
fait revenir à
c1 = a1 + b1;
return (c1); l'instruction suivant
} l'appel.

11/09/2021
III. FONCTIONS
Du point de vue du programmeur
Un programme est un ensemble de fonctions,
Il s'exécute à partir de la fonction main (),
En programmation structurée, le programme est divisé en

fonctions qui réalisent chacune une partie de la tâche. Ceci
facilite l'organisation et la mise au point du programme.

11/09/2021
III. FONCTIONS
Communication
Le programme principal main() et les fonctions ont besoin de se
communiquer des données.
Cette communication se fait par l’intermédiaire des paramètres
(appelés arguments) entre la fonction appelée et la fonction appelante.
#include <stdio.h>
int somme(int a1, int b1);
void main()
{ int a, b, c;
a=3;
b=8; int somme(int a1, int b1)
c = somme(a, b); { int c1;
printf("Somme de a et b : %d\n", c); c1 = a1 + b1;
} return (c1);
}

11/09/2021
III. FONCTIONS
Une fonction est donc définie par :

son nom
ses arguments formels
le type de la fonction (type de l'argument
retourné par la fonction)
son corps
Elle possède la même structure que le programme principal.

11/09/2021
III. FONCTIONS
Mise en œuvre:
#include <stdio.h>
Déclarer le prototype
/* 1) Le Prototypage */
int main()
{
… Appel de la fonction
/* 3) L'appel */
…
}
Définir la fonction
/* 2) La définition */
11/09/2021
III. FONCTIONS
1) Le Prototypage
La déclaration de prototype permet de définir au compilateur les
paramètres d'entrée et de sortie afin de pouvoir vérifier lors d'appel
de fonction l'ordre de passage des paramètres
Syntaxe :
Type Ident_fonc (type_1 arg1, …… , Type_k argk) ;
Type du résultat Nom de la Les paramètres

retourné fonction de la fonction
Exemple:
double puissance (double x, long N);
void racine_carre (double var);
11/09/2021
III. FONCTIONS
2) La Définition
Elle décrit l'enchaînement de toutes les instructions
permettant de réaliser la fonction.
Syntaxe : Pas de point
virgule
Type Ident_fonc (type_1 arg1, …… , Type_k argk)
{
//Déclaration des variables si besoin
instruction_1; Arguments
……………….
formels
instruction_n;
return(expression) ;
}
11/09/2021
III. FONCTIONS
3) L'Appel de la fonction
#include<stdio.h> Pendant l’appel les
#include<conio.h> Arguments passés
float puissance(float, long ); // prototype de la fonction puissance
void main()
sont appelés:
{ Arguments effectifs
float c=2.5; int l=4;
clrscr();
c = puissance(c,l); // premier appel et utilisation de puissance
printf("c : %5.2f\n", c);
c=puissance(c,l)*3.0f; // deuxième appel et utilisation de puissance Variables : c, l
printf("c : %f\n", c);
// troisième utilisation
printf("%4.2f puissance %3d = %4.2f\n",2.5,l,puissance(2.5,l)); Arguments : x, n
getch(); } Sont appelés
float puissance(float x, long n )
{ float y=1; int i=0; Arguments
for( ; i<n;i++) y= y*x; formels
return y;
}
11/09/2021
III. FONCTIONS
Deux Types de fonctions
1) Les fonctions qui retournent quelque chose possèdent un type.
Pour cela, il faut utiliser l'instruction return
Exemple :
/* Une fonction calculant le produit de deux entiers */
/* Paramètres d'entrée : deux entiers, Type retour : entier */
int calcule_produit (int a1, int a2)
{
int resultat;
resultat = a1 * a2;
return (resultat);
}
Si on ne précise pas de type a une fonction, par défaut le type

du résultat retourné est un entier
11/09/2021
III. FONCTIONS
Deux Types de fonctions
2) Les fonctions qui ne retournent rien doivent être précédées par
void. Ce type de fonctions sont également appelées procédures.
Exemple :
/* Procédure affichant le produit de deux entiers */
/* Paramètres d'entrée : deux entiers, Type retour : rien */
void affiche_produit (int a1, int a2)

{
int resultat;
resultat = a1 * a2;
printf ("Le produit de %d et %d est égal à %d", a1, a2, resultat);
}

11/09/2021
III. FONCTIONS
Fonctionnement
#include <stdio.h>
float val_abs(float y);
int main()
Passage de données:
{ xa
float c, a; 1
a = -1.5; 2
c = val_abs(a); float val_abs(float x)
printf("c : %f\n", c); {
getch(); float y;
return 0; 5 4 3 if(x<0)
} y=-x;
float val_abs(float x) return y;
{ }
float y;
if(x<0)
y=-x;
return y;
}
11/09/2021
III. FONCTIONS
Le passage des arguments en C
Entre la fonction appelante et la définition appelée se pose le
problème de la communication des arguments. On distingue
deux modes :
Passage par valeur pour les arguments en entrée : une copie

est créée, affectée de la valeur. L’appel ne modifie pas la valeur
du paramètre.
Passage par adresse, pour les arguments en entrée/sortie: le

compilateur travaille sur un alias du paramètre. La valeur du
paramètre est changée par la fonction.

11/09/2021
III. FONCTIONS Exemple de programme sans fonctions
#include <stdio.h>
int a,b,som;
void main()
{ // données
a=6;
b=14;
// Affichage des données
printf("Contenu de la variable =%d \n",a);
printf("Contenu de la variable =%d \n",b);
// Traitement
a += 4; b -=8;
som=a+b;
// Affichage des données modifiées
printf("Contenu de la variable = %d \n",a);
printf("Contenu de la variable = %d \n",b);
printf("Contenu de la variable = %d \n",som);
}
11/09/2021
III. FONCTIONS
Passage de paramètres : par valeurs
Programme Principal
void traitement(void)
{ #include <stdio.h>
a +=4; int a,b,som;
b -=8; void traitement(void);
som = a+b; void affichage(int x);
printf(" a= %d, b= %d \n", a,b); main()
} { a=6;
void affichage(int x) b=14;
{ affichage(a);
printf("Contenu de la variable = %d \n",x); affichage(b);
} traitement();
affichage(a);
affichage(b);
affichage(som);
}
//définition des fonctions
11/09/2021
III. FONCTIONS Passage de paramètres : par valeurs
Programme Principal
void traitement(int val1,int val2) #include <stdio.h>
{ int a,b,som;
val1 +=4; void traitement(int val1,int val2);
val2 -=8; void affichage(int x);
som= val1+val2; main()
printf(" val1= %d, val2= %d \n", val1,val2); {
} a=6;
b=14;
void affichage(int x) Affichage(a);
{ Affichage(b);
printf("Contenu de la variable = %d \n" ,x); traitement(a,b);
} affichage(a);
affichage(b);
affichage(som);
}
11/09/2021
III. FONCTIONS Passage de paramètres : par valeurs
Programme Principal
int traitement(int val1,int val2) #include <stdio.h>
{ int val3; int a,b,som;
val1 +=4; int traitement(int val1,int val2);
val3= val1+val2; main()
printf(" val1= %d, val2= %d \n", val1,val2); {
return val3; a=6;
} b=14;
{ Affichage(b);
printf("Contenu de la variable = %d \n" ,x); som=traitement(a,b);
} affichage(a);
affichage(b);
affichage(som);
}
11/09/2021
III. FONCTIONS Passage de paramètres : par adresse
Programme Principal
int traitement(int *val1,int val2) #include <stdio.h>
*val1 +=4; int traitement(int *val1,int val2);
val3= *val1+val2; main()
printf(" val1= %d, val2= %d \n", *val1,val2); {
return val3; a=6;
} b=4;
{ Affichage(b);
printf("Contenu de la variable = %d \n" ,x); som=traitement(&a,b);
} affichage(a);
affichage(b);
affichage(som);
}
11/09/2021
Programme Principal
int traitement(int *val1,int *val2) #include <stdio.h>
*val1 +=4; int traitement(int *val1,int *val2);
*val2 -=8; void affichage(int x);
val3= *val1+*val2; main()
printf(" val1= %d, val2= %d \n", *val1,*val2); {
return val3; a=6;
} b=14;
{ Affichage(b);
printf("Contenu de la variable = %d \n" ,x); som=traitement(&a,&b);
} affichage(a);
affichage(b);
affichage(som);
}
11/09/2021
Programme Principal
void traitement(int *val1,int *val2, int *c) #include <stdio.h>
*val1 +=4; void traitement(int *val1,int *val2, int *c);
*val2 -=8; void affichage(int x);
val3= *val1+*val2; main()
*c=val3; {
printf(" val1= %d \n", *val1); a=6;
printf(" val2= %d \n", *val2); b=14;
Affichage(a);
} Affichage(b);
void affichage(int x) traitement(&a,&b,&som);
{ affichage(a);
printf("Contenu de la variable =%d\n",x); affichage(b);
} affichage(som);
}
11/09/2021
III. FONCTIONS
Conclusion
Passage par valeur
Par défaut, les paramètres d'une fonction C sont passés par
valeur : une fonction ne peut pas modifier la valeur d'une
variable passée en paramètre.
Passage par adresse

Lorsqu'on désire qu'un paramètre soit modifié en sortie,
il faut le faire précéder d'une * à chacune de ses mentions
(déclaration du paramètre et utilisations dans le corps de
la fonction). D'autre part, il est nécessaire de placer un &
devant les arguments d'appel passés par adresse.

11/09/2021
III. FONCTIONS
Tableaux passés en paramètres à une fonction
Lorsqu’on passe un tableau en paramètre, on passe uniquement
l’adresse de ce tableau, cette adresse permet d’accéder au contenu.
Tableaux à une dimension (un indice)
Type Ident(Type *ptab, int dim_tableau, …);
OU
Type Ident(Type Tab[], int dim_tableau, …);
Tableaux à deux dimensions (2 indices)
Type Ident(Type Tab[][NCOL], int nLign, …);

OU
Type Ident(Type (*pTab)[NCOL], int nLign, …);

11/09/2021
III. FONCTIONS
Tableau à 1D passé en paramètres à une fonction
#include <stdio.h>
#include <stdlib.h>
void init_tab (int t[], int n)
{ int i;
for (i = 0; i < n; i++)
t[i] = 0;
}
main()
{ int n = 5, *A;
A= (int*)malloc(n * sizeof(int));
init_tab(A, n);
return 0;
}
11/09/2021
III. FONCTIONS Tableaux à 2D passé en paramètres à une fonction
#include <stdio.h>
#include <stdlib.h> int som(int *t, int nL, int nC)
int som(int *t, int nL, int nC); { int i, j, se = 0;
void sasir(int *t, int nL, int nC); for(i=0; i< nL; i++)
void main() for (j=0; j < nC; j++)
{ int **A, NL, NC, S, i, j; se += *(t+i*nC+j);
printf("Nombre des lignes de A : "); return se;
scanf(" %d", &NL); }
printf("Nombre des colonnes de A : ");
scanf(" %d", &NC); void sasir(int *t, int nL, int nC)
A=(int**)malloc(NL*sizeof(int*)); { int i, j;
For(i=0;i<NL;i++) for(i=0; i< nL; i++)
A[i]=(int*)malloc(NC*sizeof(int)); for (j=0; j < nC; j++)
printf(« Saisir les valeurs de A : "); scanf("%d", t+i*nC+j);
sasir((int*)A,NL,NC); }
S=som((int*)A,NL,NC);
printf("Somme des elements de A : %d\n",S); }
11/09/2021
III. FONCTIONS
Exemple
Void g_sinus(double ampl, float freq, double bo_inf, double bo_sup, float dt, double*
valeurs,)
{ double PI=atan(1.0), ti;
int i, nb_point;
nb_point=(bor_sup-bor_inf)/dt;
for(i=0; i<nb_point;i++)
{ ti=bor_inf+i*dt;
valeurs[i] = ampl* sin(2*PI*freq*ti);
}
}

11/09/2021
FIN

Cours C Partie 5

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Cours C Partie 5

Transféré par

Droits d'auteur :

Formats disponibles

Ecole supérieure de Technologie

Département de Génie Electrique

Khalid SBAI – Cours D’Informatique

Enoncé d’un problème

Sous- … Sous- … Sous-

Chacun réalise une tâche bien définie

Structuration d’un programme

C'est un code exécutable à une adresse en mémoire terminé par

A l'appel de la fonction, le μ-processeur exécute le code à partir

Des données peuvent être transmises à la fonction en

Khalid SBAI – Cours D’Informatique

Khalid SBAI – Cours D’Informatique

Un programme est un ensemble de fonctions,

Il s'exécute à partir de la fonction main (),

En programmation structurée, le programme est divisé en

Khalid SBAI – Cours D’Informatique

Khalid SBAI – Cours D’Informatique

Une fonction est donc définie par :

Elle possède la même structure que le programme principal.

Khalid SBAI – Cours D’Informatique

Type du résultat Nom de la Les paramètres

Si on ne précise pas de type a une fonction, par défaut le type

void affiche_produit (int a1, int a2)

Khalid SBAI – Cours D’Informatique

Passage par valeur pour les arguments en entrée : une copie

Passage par adresse, pour les arguments en entrée/sortie: le

Khalid SBAI – Cours D’Informatique

Passage par adresse

Khalid SBAI – Cours D’Informatique

Type Ident(Type Tab[][NCOL], int nLign, …);

Khalid SBAI – Cours D’Informatique

Khalid SBAI – Cours D’Informatique

Khalid SBAI – Cours D’Informatique

Vous aimerez peut-être aussi