Assurée par :

Emna Ammar Elhadjamor

1ére LGC ----------------- Algorithmique et programmation----------------- 2020/2021

 La programmation modulaire ou procédurale consiste à découper
un programme en plusieurs parties appelées sous programmes ou
modules.
 Un sous-programme est un ensemble de données et
d’instructions qui décrit un ensemble d’actions résolvant un
problème particulier.

2
 Les intérêts de la programmation modulaire sont multiples :
 Faciliter la résolution d’un problème complexe,
 Diminuer les risques d’erreurs (en évitant la duplication),
 Effectuer les tests d’une façon sélective,
 Réutiliser des sous programmes déjà existants,
 Avoir une meilleure lisibilité,
 Simplifier la maintenance (l’entretien) des programmes.

3
 En algorithmique, un sous-programme peut être soit une
fonction ou bien une procédure.
 Une fonction est un sous-algorithme qui, à partir de donnée(s),
calcul et rend à l’algorithme un seul résultat alors qu’en général,
une procédure affiche le(s) résultat(s) demandé(s).

4
 Les paramètres utilisés lors de la définition (déclaration) d’un
sous-programmes sont dits : paramètres formels.
 Les paramètres utilisés lors de l’appel à un programme sont dits :
paramètres effectifs.
 Il y a deux types de paramètres : paramètres d’entrées (les
valeurs à transmettre au Sous Programme) et paramètres de
sorties (les résultats à récupérer).

5
 Un paramètre est une entrée de l’en-tête de la fonction, il "annonce"
l’argument. Les paramètres ne peuvent changer pendant l’exécution du
programme.
 Un argument est une donnée transmise à la fonction par le programme
appelant. Chaque fois que la fonction sera appelée, le programme
pourra lui transmettre des valeurs d’arguments différents. Par contre, le
nombre et le type des arguments transmis ne doivent pas changer.
L’argument est référencé par le nom correspondant dans la liste de
paramètres.

6
7
 Les Paramètres Formelles sont les paramètres utilisés dans la
déclaration du sous-programme :
 Séparés par des ; (point-virgule)
 Non précédé par var : passage par valeur (entrée).
 Précédé par var : passage par variables (sortie)
 Les paramètres avec passage par valeur sont des paramètres
d’entrée.
 Les paramètres avec passage par variables sont des paramètres
d’entrée/sortie.

8
 Les Paramètres Effectif sont les paramètres utilisés dans l’appel
à la procédure:
 Séparés par des , (virgule)
 Nombre de paramètre effectifs est le même que les paramètre
formels du sous-programme.
 Pour réaliser les tâches dédiées à une procédure, il faut l’appeler
dans un algorithme ou un programme.
 L’ordre des paramètres formels doit être respecté lors de l’appel.
 L’appel d’une procédure peut être effectué en spécifiant, au
moment souhaité, son nom et éventuellement ses paramètres.

9
 Deux techniques différentes d'échange d'informations par
arguments sont utilisables par la plupart des langages de
programmation, à savoir la transmission par valeur et la
transmission par adresse.

10
 Au moment de l’appel les paramètres effectifs sont affectés
l’un après l’autre dans les paramètres formels (on dit qu’il y a
lecture)
 Mais au moment du retour à l’appelant rien n’est fait (on dit
qu’il n’y a pas d’écriture)
 Par conséquent il n’y a pas de modifications des paramètres
effectifs.

11
#include <stdio.h>
void NeModifiePas(int x)
{
x = x+1; /* le x local est modifiée, pas
le x du main */
}
int main(void)
{
int x=1;
NeModifiePas(x);
printf("%d", x); /* affiche 1 (valeur
inchangée) */
}
12
 Au moment de l’appel les paramètres effectifs sont affectés
l’un après l’autre dans les paramètres formels (on dit qu’il y a
lecture),
 Après le traitement au sein de la fonction et au moment du
retour à l’appelant les informations qui sont dans les
paramètres formels sont affectés dans les paramètres effectifs
(on dit qu’il y a écriture).
 Par conséquent les valeurs des paramètres effectifs seront
modifiées.

13
 L’idée du passage par adresse est que, pour modifier une
variable par un appel de fonction, il faut passer en paramètre
non pas la variable, mais un pointeur qui pointe
sur la variable. Ainsi, le paramètre est l’adresse de x.
 Lorsqu’on modifie la mémoire à cette adresse, la donnée x
est modifiée, car on travaille bien sur l’emplacement
mémoire de x.

14
 En algorithmique, au moment de la définition d’une
procédure, les paramètres transmis par adresse et sont
précédés par le mot VAR.
 En langage C, au moment de la définition d’une procédure,
les paramètres transmis par adresse sont précédés par le
caractère (*) et au moment de l’appel de la procédure dans un
programme, ces paramètres sont précédés par &.

15
#include <stdio.h>
void Modifie(int *p) /* paramètre de type pointeur
*/
{
*p = *p+1; /* ce pointeur p a pour valeur &x (x du
main) */

}
int main(void)
{
int x=1;
Modifie(&x); /* on passe directement l’adresse de
x */
printf("%d", x); /* affiche 2 */
return 0;
}
16
 Une procédure est un sous-programme qui permet la résolution
d’un problème précis et qui peut avoir zéro ou plusieurs
résultats.
 Syntaxe en algo:
Procédure Nom_Procédure (Nom_Paramètre :
Type_praramètre;……) ; //Paramètres Formelles
//Déclaration Variables locales
Nom_variable : Type_variable ; …
Début
Instructions … ; //Corps de la procédure
Fin

17
 Écrire une procédure permettant d’afficher la somme de deux
entiers.
Algorithme affiche
Variable x,y : entier
Procédure aff_somme(a :entier, b :entier)
//paramètres formels
Variable S : entier
Début /*proc*/
S  a + b
Écrire(S)
Fin /*proc*/
Début /*algo*/
Écrire(‘donnez un entier x : ‘), Lire(x)
Écrire(‘donnez un entier y : ‘), Lire(y)
aff_somme(x,y) /*appel de la procédure
aff_somme par son nom et ses paramètres effectifs,
dans le programme appelant */
Fin /*algo*/ 18
 Dans un programme en C, généralement, une procédure est dite
une fonction sans valeur de retour. Elle est définie en utilisant
le mot clé void .
 Si elle n’attend pas de paramètres, sa liste de paramètres sera
void ou n’existera pas.
 Il n’est pas nécessaire de mettre une instruction return à la fin
d’une fonction qui ne renvoie pas de valeur.

19
 Syntaxe en C:
void nomproc (type Param1, type Param2, …,
type ParamN)
{
//Déclaration des variables
//Suite d’instructions
}

20
 Exemple:
#include <stdio.h>
void afficher (void); /*La fonction afficher
n'a ni paramètre ni résultat*/
main( )
{afficher();}
void afficher(void) /*affiche le message
bonjour*/
{printf("bonjour"); }

21
 Une fonction est un bloc d’instructions qui retourne obligatoirement
une valeur résultat à l’algorithme appelant.
 Etant donné qu’une fonction a pour but principal de renvoyer une
valeur, il est donc nécessaire de préciser le type de la fonction qui est
en réalité le type de cette valeur.
 Dans une fonction, on trouve des instructions qui produisent le
résultat ; ce dernier doit être affecté en fin de traitement au nom de la
fonction.

22
 Syntaxe en algo:
Fonction Nom_Fonction (Nom_Paramètre :
Type_praramètre;……) : type_Fonction ;
Nom_variable : Type_variable … ;
//Variables locales
Début
Instructions …; //Corps de la fonction
Nom_Fonction  Résultat
Fin ;

23
 Écrire une fonction qui retourne la valeur absolue d’un entier N.
Fonction Val_abs(N : entier) : entier
Variable a : entier
Début
Si (N > 0) Alors
a  N
Sinon
a  -N
FinSi
Val_abs  a /* affecter le
résultat a au nom de la fonction : Val_abs
*/
Fin 24
 Écrire une fonction qui retourne la moyenne de deux réels x et y.
Fonction Moyenne(x : réel, y : réel) : réel
Début
Moyenne  (x+y)/2
Fin
 Pour l’appel de cette fonction dans le programme principale, il
faut soit mettre ce réel dans une variable de même type en
faisant une affectation, soit afficher ce réel à l’aide de la
primitive d’écriture.
Nomvar  nomfonct(var1, var2,…, varN)
ou bien
Écrire(nomfonct(var1,var2,…..,varN)
25
Algorithme Calcul
Variable a,b : réel
Fonction Moyenne(x : réel, y : réel) : réel
Début
Moyenne  (x+y)/2
Fin
Début /* programme appelant */
Lire(a)
Lire(b)
Écrire(Moyenne(a,b))
Fin

26
 Syntaxe en C:
type_retour identificateur(paramètres)
{
/* Instructions de la fonction */
}
Type_retour : le type de la valeur renvoyée;
Identificateur: le nom de la fonction;
Paramètres: la liste de paramètres

27
 Une fonction qui ne doit pas recevoir de paramètre a une liste
d’arguments qui contient void :
type_retour identificateur(void)
 Exemple:
La fonction PI fournit un résultat rationnel du type float.
La liste des paramètres de PI est déclarée comme void (vide), c’est-à-
dire PI n'a pas besoin de paramètres et il faut l'appeler par : PI()
float PI(void)
{return 3.1415927;
}

28
/*Un exemple de fonction qui prend deux paramètres 'a' et
'b' en entrée et retourne la somme de deux nombres en
entrée */
int somme(int a, int b){
int c;
c=a+b;
return c;
}
// fonction principale
int main()
{
int a=5,b=3,s;
s=somme(a,b); /*l’appel est par l’affectation*/
printf("la somme est : %d", s);
/*ou bien l’appel par le nom printf("la somme est : %d",
somme(a,b));*/
return 0;
}
29
int Min(int, int);/* Déclaration de la fonction
minimum */
int main(void){/* Fonction principale.*/

int a=2, b=3, i;

i = Min(a,b); /* Appel à la fonction Min, déjà
déclarée. */
return 0;
}

int Min(int i, int j) /* Définition de la fonction

min. */
{ if (i< j)
return i;
else return j;
}

30
/* Calcul du produit de deux nombres. */
#include <stdio.h>
int produit(int x, int y);
int main()
{int a,b,c;
printf("Entrez un nombre entre 1 et 100 : ");
scanf("%d", &a); /* Lecture du premier nombre */
printf("Entrez un autre nombre entre 1 et 100 : ");
scanf("%d", &b); /* Lecture du deuxième nombre */
/* Calcul du produit et affichage du résultat */
c = produit(a, b);
printf ("\n%d fois %d = %d", a, b, c);
return 0;
}
/* La fonction renvoie le produit de ses deux arguments */
int produit(int x, int y)
{return (x * y); }
Entrez un nombre entre 1 et 100 : 35
Entrez un autre nombre entre 1 et 100 : 23
35 fois 23 = 805 31
#include <stdio.h>
#include <stdlib.h>
long cube(long x);
long input, reponse;
int main()
{printf("Entrez une valeur entière : ");
scanf("%d", &input);
reponse = cube(input);
/* Note: %ld est la spécification de conversion d’un entier long
*/
printf("\n\nLe cube de %ld est %ld\n.", input, reponse); }
long cube(long x)
{long x_cube;
x_cube = x * x * x;
return x_cube; }
Entrez un nombre entier : 100
Le cube de 100 est 1000000
Entrez un nombre entier : 9
Le cube de 9 est 729
Entrez un nombre entier : 3
32
Le cube de 3 est 27
/* l’appel est par valeur*/
#include void echanger(Int V1, Int V2)
{ int inter ;
inter = V1 ; /*on est en train de manipuler les
valeurs*/
V1 = V2 ;
V2 = inter ; }
main() {
int a, b ;
a = 14 ; b = 23 ;
printf("avant : a = %d b = %d\n", a,b) ;
echanger(a, b) ; /*Envoi des valeurs de a et de
b*/
printf("aprés : a = %d b = %d\n", a,b) ; }
------------------------------------------
Après le traitement le résultat est :
avant : a = 14 b = 23 après : a = 14 b = 23 33
/* l’appel est par variable*/
#include void echanger(int *V1, int *V2)
{ int inter ;
inter = (*V1) ; /*On est en train de manipuler
les adresses*/
(*V1) = (*V2) ;
(*V2) = inter ; }
main() {
int a, b ;
a = 14 ; b = 23 ;
printf("avant : a = %d b = %d\n", a,b) ;
echanger(&a, &b) ; /*Envoi des adresses de a et
de b*/
printf("aprés : a = %d b = %d\n", a,b) ; }
--------------------------------------
Après le traitement le résultat est : Avant : a
= 14 b = 23 Après : a = 23 b = 14 34