EXERCICES DE PROGRAMMATION

PROCÉDURALE
BAC1 ESI TS

A M A
Y
Prof. Blaise FYAMA

F
Collaborateur : Msc 2 : Ruphin NYAMI

l a is e
f . B
Pro 2023
 ARRANGEMENTS
• Le nombre d'arrangements de n objets
pris p par p est donné par la formule

A M A
e F Y
is
Soit, en simplifiant

. B l a
ro f
P
 Solution arrangement

A M A
e F Y
l a is
f . B
Pro
Exemple avec le Chiffrement de César

A M A
e F Y
l a is
f . B
Pro
 Fonction strlen
#include <string.h>

size_t strlen( const char * theString );

M A
Cette fonction permet de calculer la longueur, exprimée en

A
Y
nombre de caractères, de la chaîne de caractères.

F
En langage C, les chaînes de caractères sont dites AZT : A Zéro

s e
Terminal.

l a i
Cela signifie qu'une chaîne de caractères se termine forcément par

. B
un code ASCII nul (pouvant aussi être représenté par '\0').

ro f
Attention, la fonction strlen ne compte pas ce caractère de fin :

P
seuls les caractères "utiles" de la chaîne sont considérés.
 Exemple

A M A
e F Y
l a is
f . B
Pro
 Chiffrement

A M A
e F Y
l a is
f . B
Pro
 Sous forme de pointeur

A M A
e F Y
l a is
f . B
Pro
 Message saisie dans le clavier

A M A
e F Y
l a is
f . B
Pro
 Fonction rand : Générer des valeurs Aléatoires
int rand();

A
Time() : renvoi le temps écoulé depuis le
premier janvier 1970 à [Link]

Y A M
s e F
i
Srand(): La fonction srand permet d'initialiser le

B l a
générateur de nombres aléatoires (la fonction rand )

.
f
fournit par la librairie C standard.

P ro
 La fonction time()

A M A
e F Y
l a is
f . B
Pro
 Exemple de RAND

A M A
e F Y
l a is
f . B
Pro
 A M A
e F Y
l a is
f . B
Pro
 A M A
e F Y
l a is
f . B
Pro
TP 1 : Devinette
Le principe est le suivant :
L'ordinateur tire au sort un nombre entre 1 et 100

A
Il vous demande de deviner le nombre. Vous rentrez donc un nombre

M
entre 1 et 100

Y A
L'ordinateur compare le nombre que vous avez rentré avec le nombre

F
"mystère" qu'il a tiré au sort. Il vous dit si le nombre mystère est

e
supérieur ou inférieur à celui que vous avez entré

is
Puis, l'ordinateur vous redemande le nombre ... Et il vous indique si le

l a
nombre mystère est supérieur ou inférieur. Et ainsi de suite, jusqu'à ce

B
que vous ayez trouvé le nombre mystère.

f .
Le but du jeu, bien sûr, est de trouver le nombre mystère en un

ro
minimum de coups

P
int main ( )
{
long nombreMystere = 0, nombreEntre = 0;
const long MAX = 100, MIN = 1; nombreMystere =
(rand() % (MAX - MIN + 1)) + MIN;
do

A
{

M
printf("Quel est le nombre ? ");

A
scanf("%ld", &nombreEntre); if (nombreMystere >

Y
nombreEntre)

F
printf("C'est plus !\n\n"); else if (nombreMystere

s e
< nombreEntre)

a i
printf("C'est moins !\n\n"); else printf ("Bravo,

l
vous avez trouve le nombre mystere !!!\n\n");

f . B
} while (nombreEntre != nombreMystere);

ro
return 0;

P
}
 Les fonctions
• Une fonction est un sous-programme ou bloc
d’instructions écrit pour réaliser une tâche

A
particulière.

A M
• Une même fonction peut être incluse dans

Y
F
plusieurs programmes, ou plusieurs fois dans

is
un même programme.

l a e
f . B
P ro
 LES FONCTIONS (1)

=? A
Y A M
s e F
i
x : est appelé ici paramètre ou argument de la fonction

. B l a
f : est la fonction elle –même

ro f
() : signifie ce que la fonction attends pour donner le
P
résultat
 Fonction : Argument (1)
• Les arguments de la fonction sont appelés paramètres formels, par
opposition aux paramètres effectifs qui sont les paramètres avec

A
lesquels la fonction est effectivement appelée.

M
• Une fonction qui ne renvoie pas de valeur est une fonction dont le type

A
est spécifié par le mot-clef void.

F Y
• Les paramètres formels peuvent être de n'importe quel type.

e
is
• Leurs identificateurs n'ont d'importance qu'à l'intérieur de la fonction.

l a
• Enfin, si la fonction ne possède pas de paramètres, on remplace la liste

f . B
de paramètres formels par le mot-clef void.

P ro
 Fonction explications (2)
• Le corps de la fonction débute éventuellement

A
par des déclarations de variables, qui sont locales

M
à cette fonction.

Y A
• Il se termine par l'instruction de retour à la

F
e
fonction appelante, return, dont la

l a is
B
syntaxe est return(expression);

ro f .
P
 Explications (3)
#include <stdlib.h>
Directives du préprocesseurs
#include <time.h>
int main()

A
fonction

M
{

Y A
printf("KARIBU KWETU "); Instruction

F
return 0;
}

l a is e
f . B
P ro
 A
a : le type de résultats retournés par la fonction
b: le nom ou l’identificateur de la fonction

Y A M
F
c : les arguments de la fonction

is e
d: l’instruction qui retourne le résultat du même type que a

l a
B
{ : début de la fonction

ro f .
} : fin fonction

P
 Avant la fonction
main

A M A
e F Y
l a is
f . B
Pro
 Appel de la fonction
L'appel d'une fonction se fait par
l'expression

A
nom-fonction(para-1, para-2,...,para-n)

Y A M
F
• L'ordre et le type des paramètres effectifs de la

e
fonction doivent concorder avec ceux donnés dans

a is
l'en-tête de la fonction.

B l
• Les paramètres effectifs peuvent être des

f .
expressions.

P ro
 A M A
e F Y
l a is
f . B
Pro
 Contre exemple

A M A
e F Y
l a is
f . B
Pro
 Contre exemple 2

A M A
e F Y
l a is
f . B
Pro
 Contre exemple 3

A M A
e F Y
l a is
f . B
Pro
 Contre exemple 4

A M A
e F Y
l a is
f . B
Pro
 A M A
e F Y
l a is
f . B
Pro
 A M A
e F Y
l a is
f . B
Pro
 void : la fonction qui ne renvoi rien

A M A
e F Y
l a is
f . B
Pro
 Contre exemple void

A M A
e F Y
l a is
f . B
Pro
 Exercices
1) Ecrire une fonction qui demande à
utilisateur de saisir son nom, son âge et
affiche bonjour tout en indiquant son âge

A M
2) Ecrire une fonction Crypto qui demande
A
F Y
à l’utilisateur son prénom et lui affiche les

e
s
valeurs ASCII correspondants

B l a i
3) Écrire une fonction qui calcul la factorielle

ro f .
d’un nombre

P
 A M A
e F Y
l a is
f . B
Pro
 A M A
e F Y
l a is
f . B
Pro
 les prototypes de fonction
• Un prototype est une signature de fonction. Comme
tout objet en C, une fonction doit être déclarée avant
son utilisation. Cette déclaration est le prototype de la

A
fonction.

M
• Le prototype doit indiquer au compilateur le nom de la

Y A
fonction, le type de la valeur de retour et le type des

F
paramètres (sauf pour les fonctions à arguments

s e
variables, comme printf().

l a i
int fa(int a, char const * const b);

B
f .
int fb(int, char const * const);

P ro
 Où déclarer les prototypes ?
Un prototype de fonction doit être déclaré avant
l'utilisation de la fonction.

A
Pour une plus grande lisibilité, mais aussi pour simplifier

A M
la maintenance du code, il est conseillé de regrouper

Y
F
tous les prototypes d'un module (fichier xxx.c) dans un en-

s e
tête (<xxx.h>).

l a i
Ce dernier n'a plus alors qu'à être inclus dans le code qui

B
.
utilise ces fonctions. C'est le cas des fonctions de la

ro f
bibliothèque standard.

P
 Quels sont les prototypes valides de main() ?
La fonction main() renvoie toujours un int. Les
prototypes valides sont :
int main(void);

A
int main(int argc, char * argv[]);

Y
Enfin, rappelons que le prototype suivant
A M
F
int main();

l a is e
f . B
P ro
 Comment printf() peut recevoir différents
types d'arguments ?
printf() est une fonction à nombre variable de

A
paramètres. Son prototype est le suivant :

M
int printf(const char * format, ...); /* C 90 */

Y A
int printf(const char * restrict format, ...); /* C 99 */

s e F
B l a i
ro f .
P
 Prototype

A M A
e F Y
l a is
B
implémentatio

ro f . n

P
 Exemple d’une fonction
int produit (int a, int b)
{
A M A
return(a*b);
e F Y
}
l a is
f . B
Pro
 Déclaration d'une fonction
int produit(int, int );
Prototype
int produit (int a, int b)
{

A
return(a*b);
}

Y A M
F
int main()

s e
{

l a i
int a = 2, b = 5;

. B
printf("%d\n", puissance(a,b));

ro f
}

P
 Créer une fonction

A M A
e F Y
l a is
f . B
Pro
 Exercice 1
int somme(int n1, int n2, int n3){
return (n1 + n2 + n3);
}

int main(){
A M A
int a = 10;

e F Y
is
a += somme(5, 6, 4);

B l a
printf("%d \n", a);

.
ro f
}

P
 Exercice 2
int somme(int n1, int n2, int n3){
return (n1 + n2 + n3);
}

A
int main(){
int a = 10;

Y A M
F
a +=(somme(5, 6, 4) + somme(20, 10,

is e
15)) );

l a
printf("%d \n", a);
}
f . B
P ro
 Exercice 3
int somme(int n1, int n2, int n3){
return (n1 + n2 + n3);
}

int main(){
A M A
int a = 10;

e F Y
is
a += somme(20, 6);

B l a
printf("%d \n", a);

.
ro f
}

P
 Modifier la valeur de la fonction

A M A
e F Y
l a is
f . B
Pro
 Plusieurs paramètres

A M A
e F Y
l a is
f . B
Pro
 Aucun paramètre

A M A
e F Y
l a is
f . B
Pro
 Exercices

A M A
e F Y
l a is
f . B
Pro
 La punition

A M A
e F Y
l a is
f . B
Pro
 LA FONCTION TABLE DE MULTIPLICATIONS

A M A
e F Y
l a is
f . B
Pro
 Durée de vie des variables
•Variables statiques (permanentes)
•Variables temporaires
•Variables Globales
A M A
•Variables locales
e F Y
l a is
f . B
P ro
 Variables Statiques
Une variable permanente (statique) occupe un
emplacement en mémoire qui reste le même durant toute
l'exécution du programme.

A M A
Y
Cet emplacement est alloué une fois pour toutes lors de la

F
compilation.

is e
La partie de la mémoire contenant les variables permanentes

l a
est appelée segment de données.

f . B
ro
Elles sont caractérisées par le mot-clef static

P
 A M A
e F Y
l a is
f . B
Pro
 Variables Globales
On appelle variable globale une variable déclarée

A
en dehors de toute fonction.

M
Une variable globale est connue du compilateur

Y A
dans toute la portion de code qui suit sa

F
e
déclaration.

l a is
Les variables globales sont systématiquement

. B
permanentes.

ro f
P
 A M A
e F Y
l a is
f . B
Pro
 Variables Globales : Exemple

A M A
e F Y
l a is
f . B
Pro
 Variables locales
Une variable locale est une variable déclarée à
l'intérieur d'une fonction (ou d'un bloc

A
d'instructions) du programme.

A M
Par défaut, les variables locales sont temporaires.

Y
F
Quand une fonction est appelée, elle place ses

s e
variables locales dans la pile.

l a i
Les variables locales n'ont en particulier aucun lien

B
.
avec des variables globales de même nom.

ro f
P
Variables locales : exemples

A M A
e F Y
l a is
f . B
Pro
 La programmation modulaire
• Un programme en C est composé de plein de
fonctions.

A
• Chaque fonction sert à faire un travail précis et

M
renvoie généralement un résultat.

Y A
• C'est en assemblant toutes ces fonctions entre elles

F
e
que l'on parvient à créer n'importe quel

a is
programme en informatique

l
. B
Plus le programme devient long, plus il devient

ro f
illisible dans main.c

P
 Les headers
Jusqu'ici, nous n'avions qu'un seul fichier source dans notre projet.
Ce fichier source « main.c ».
• Plusieurs fichiers par projet

A
Les programmes ne seront pas tous écrits dans ce même fichier main.c. quand

M
bien même c'est possible de le faire, mais ce n'est jamais très pratique. Au

A
risque de faire un plat de spaghettis.

F Y
C'est pour cela qu'en général on crée plusieurs fichiers par projet.

e
Un projet, c'est l'ensemble des fichiers source du programme.

l a is
f . B
P ro
 Fichiers .h et .c
• Les .h : appelés fichiers headers. Ces fichiers contiennent les
prototypes des fonctions.
• Les .c : les fichiers sources. Ces fichiers contiennent les fonctions

M A
elles-mêmes.

Y A
En général, on met donc rarement les prototypes dans les fichiers

F
.c comme on l'a fait tout à l'heure dans le main.c (sauf si votre

s e
programme est tout petit).

l a i
Pour chaque fichier .c, il y a son équivalent .h qui contient les

B
.
prototypes des fonctions.

ro f
Il faut inclure le fichier .h grâce à une directive de préprocesseur.

P
 Fichier entête
Plutôt que de commencer chaque fichier source par une liste de déclarations
des objets définis dans d'autres fichiers sources, la communication entre les
fichiers qui définissent un nom et ceux qui l'utilisent est assurée par des
sources particuliers.

M A
Il y a en effet deux sortes de fichiers sources :

A
les fichiers d'en-tête, dont le nom se termine traditionnellement en .h et les

F Y
fichiers de définitions, qui sont des .C.

e
Les .h permettent de partager des déclarations entre plusieurs .C composant

is
un même programme.

l a
Les .h doivent être inclus dans les .C au moyen de la directive suivante du

. B
préprocesseur, placée en tête du .C : #include "declarations.h"

ro f
P
 Fichier entête
Le nom du fichier d'en-tête est placé entre " ..." et non entre
< ...>, qui est réservé aux en-têtes standards (comme stdio, math,
etc).

M A
Un fichier d'en-tête peut contenir les éléments suivants :

A
directives d'inclusion (#include)

F Y
définitions et déclarations de type (#define)

e
is
déclarations d'objets

l a
déclarations de fonction

f . B
définitions de constantes (const)

P ro
 Directives du préprocesseur : #incmude
• Les commandes destinées au
préprocesseur commencent toutes
par # en début de ligne.
A M A
e F Y
l a is
f . B
P ro
 Inclusion de fichiers
#include "nom_du_fichier.h" :
fichier dans le projet courant

A M A
Y
#include <nom_du_fichier.h> :

e
biliothèque de l’IDE

s F
B l a i
ro f .
P
 #define, #undef
Cette directive permet de définir une constante de
préprocesseur. Cela permet d'associer une valeur à
un mot.

A
#define nom_commande : définie un mot qui
M A
Y
sera remplacé par la valeur à l’exécution

s e F
i
#undef nom_commande : permet d’effacer

l a
une commande définie avant

f . B
P ro
 #define, #undef
#define TAUX_DU_JOUR 200

A
L’ordre de déclaration est la suivante

M
•le#define;

Y
•le mot auquel la valeur va être associée ;

F A
e
•la valeur du mot.

l a is
f . B
P ro
 « Les define » et const
const int TAUX_DU_JOUR = 200; | #define TAUX_DU_JOUR 200

Les constantes occupaient de la place en mémoire

A M A
Y
la mémoire.

s e F
En fait, le #define remplace dans votre code

a i
source tous les mots par leur valeur correspondante

f . B l
P ro
 Toutes ces directives pour la
compilation conditionnelle
#ifdef, #ifndef, #if, #endif et

A
#else.

A M
#ifdef : permet de compiler les instructions si

Y
F
une commande a été définie (par la

i
directive #define).

l a s e
f . B
ro
#endif : indique la fin de la partie de code

P
conditionnelle.
 Toutes ces directives pour la
compilation conditionnelle
#ifdef, #ifndef, #if, #endif et

A
#else.

A M
#ifndef : permet de compiler les instructions si

Y
F
une commande n’a pas été définie (l’inverse de
#ifdef).

l a is e
f . B
#endif : indique la fin de la partie de code

P ro
conditionnelle.
 Toutes ces directives pour la
compilation conditionnelle
#ifdef, #ifndef, #if, #endif et

A
#else.

Y A M
#if : permet de tester si une expression (définie
par #define) est vraie.

s e F
B l a i
.
#endif : indique la fin de la partie de code

ro f
conditionnelle.

P
#include <stdio.h>
#include <stdlib.h>

#define FRENCH

A
int main(){

M
#ifdef FRENCH
puts("Bonjour ");

F YA
e
#else

a is
puts("Hello");

B
#endif // FRENCH

f . l
ro
return 0;

P
}
 LES MACROS
Un Macros est une commande définie avec
#define ayant comme valeur code sources

A M A
e F Y
l a is
f . B
P ro
 Types de Macros
•Macro sans paramètres
•Macro avec paramètres
A M A
e F Y
l a is
f . B
Pro
 Exemple de macros sans paramètres

A M A
e F Y
l a is
f . B
Pro
 A M A
e F Y
l a is
f . B
Pro
 Exemple de macros avec paramètres
#include <stdio.h>
#include <stdlib.h>

#define DELIBERATION(pourcentage)\

A
if(pourcentage >= 50)\

A M
puts("Bravo");\

Y
else \

e F
puts("Desolé, Ajourné ");

l a is
B
int main(){

f .
DELIBERATION(50);

ro
return 0;

P
}
Exemple de calcul de Delta avec un macros

A M A
e F Y
l a is
f . B
P ro
 Macros

A M A
e F Y
l a is
f . B
Pro
 Adresse et valeur d'un objet
On appelle Lvalue (left value) tout objet pouvant être placé à gauche d'un
opérateur d'affectation. Une Lvalue est caractérisée par :
•son adresse, c'est-à-dire l'adresse-mémoire à partir de laquelle l'objet est
stocké ;

A
•sa valeur, c'est-à-dire ce qui est stocké à cette adresse.

M
Dans l'exemple,

Y A
int i, j;

F
i = 3; j = i;

e
Si le compilateur a placé la variable i à l'adresse 4831836000

is
en mémoire, et la variable j à l'adresse 4831836004, on a

. B l
objet
a adresse valeur

ro f
i 4831836000 3

P
j 4831836004 3
 Notion de pointeur
int i = 3;
int *p;

A
p = &i;

A M
On se trouve dans la configuration

e F Y
a is
objet adresse valeur

B l
i 4831836000 3

f .
p 4831836004 4831836000

P ro
 Exemple :
L'opérateur unaire d'indirection * permet d'accéder directement à la
valeur de l'objet pointé.
Ainsi, si p est un pointeur vers un entier i, *p désigne la valeur de i.

A
Par exemple, le programme

M
objet adresse valeur

A
main() {

Y
i 4831836000 3

F
int i = 3;
p 4831836004 4831836000

e
int *p;

is
p = &i; *p 4831836000 3

B l a
printf("*p = %d \n",*p); } imprime *p = 3.

.
ro f
P
 Allocation dynamique
Ainsi, pour initialiser un pointeur vers un
entier, on écrit :

A
int *p; p = (int*)malloc(sizeof(int));

A M
On aurait pu écrire également

Y
p = (int*)malloc(4);

e F
puisqu'un objet de type int est stocké sur

s
a i
4 octets.

B l
Mais on préférera la première écriture qui a

f .
ro
l'avantage d'être portable.

P
 Les pointeurs, Les Tableaux et les
Structures
1. Le Pointeur
Définition : Un pointeur est une variable dont sa valeur vaut l’adresse

A
mémoire d’une autre variable.

A M
Exemple:

Y
1. long age = 18;

F
2. long *pAge;

e
3. pAge = &age;

is
*

a
Le symbole :

l
devant la variable pAge signifie que cette variable là doit pointer

B
une adresse mémoire d’un entire long.

f .
Ligne n° 3 : pAge = &age; : le symbole esperluette “&” signifie l’adresse mémoire de

ro
la variable age et non sa valeur 18. donc la valeur de pAge = l’adresse mémoire de
age.

P
 Exemple sur le pointeur
#include <stdio.h>
#include <stdlib.h>
int main()

A
{
long age = 18;

YA M
F
long *pAge;
pAge = &age;

l a ise
B
printf("%ld \n", pAge);

ro f .
return 0;

P
}
 Exemple 2 :
int main()
{
long age = 18;

A
long *pAge;

M
pAge = &age;

Y A
printf("%ld \n", pAge);

F
//affiche sa valeur qui est l'adresse de age;

age
is e
printf("%ld \n", *pAge); // affiche la valeur de

l a
f . B
return 0;

ro
}

P
 Exemple 3 : modifier la valeur par un pointeur
int main()
{
long age = 18;

A
long *pAge;

M
pAge = &age;

Y A
*pAge += 18;

F
printf("%ld \n", &age);//age affinche son adresse memoire

is e
printf("%ld \n", age);//age affiche sa valeur

l a
printf("%ld \n", *pAge); // pAge affiche la valeur de age

f . B
printf("%ld \n", pAge);//pAge affiche sa valeur;

ro
return 0;

P
}
 Pointeur
a: entier
a10

A
p : ↑Entier
pAdresse(a)

Y A M
e F
p↑
p↑ 

l a is
p↑ 

f . B
ro
a 

P
p↑
 Explication exemple 3

A M A
e F Y
l a is
f . B
Pro
int main()
{
long age = 18;
long nombre = 100;
long *pAge, *pNombre;
pAge = &age;
pNombre = &nombre;

A
printf("l adresse de age = %ld \n", &age);

M
printf("La valeur du Pointeur pAge = %ld \n", pAge);

Y A
printf("l adresse de Nombre = %ld \n", &nombre);

F
printf("La valeur du Pointeur pNombre = %ld \n", pNombre);

is e
printf("la valeur de age = %ld \n", age);

l a
printf("La valeur stockee dans l adresse de age = %ld \n", *pAge);

B
printf("La valeur de Nombre = %ld \n", nombre);

f .
printf("La valeur stockee dans l adresse de Nombre = %ld \n", *pNombre);

ro
return 0;

P
}
 A M A
e F Y
l a is
f . B
Pro
Pointeur : suite de chaines sans limite

A M A
e F Y
l a is
f . B
P ro
 Exemple 2 : Chaine de caractère

A M A
e F Y
l a is
f . B
Pro
 Fonctions de chaines
a)strcmp(char, char)
Permet de comparer si deux chaines
sont identique. Elle retourne deux
A M A
Y
valeurs :

e F
0 : si le deux chaines sont identique
s
l a i
1 : si le deux chaines sont
B
ro f .
différentes.
P
 Exemple avec strcmp()
char chaine1[] = "RDC", chaine2[] = "RDC";
if (strcmp(chaine1, chaine2) == 0){
printf("Les chaines sont identiques\n");}

A
else

A M
{

F Y
printf("Les chaines sont differentes\n");

e
}

l a is
B
return 0;

ro f .
}

P
 La fonction strlen()
strlen(char) : renvoi la taille de la chaine
de caractère ou d’un tableau de chaine.

A M A
e F Y
l a is
f . B
P ro
Déclaration d’un Tableau à deux dimensions :
Plan

A M A
e F Y
l a is
f . B
P ro
 Affectation de valeurs à un Tableau
long tableau[3][4] ;
tableau[0][0] = 5;
tableau[0][1] = 37;
tableau[0][2] = 2;

A
tableau[0][3] = 10;

M
tableau[1][0] = 27;

YA
tableau[1][1] = 16;

F
tableau[1][2] = 9;

is e
tableau[1][3] = 11;

l a
tableau[2][0] = 24;

. B
tableau[2][1] = 22;

ro f
tableau[2][2] = 8;

P
tableau[2][3] = 55;
 Déclaration avec initialisation
long tableau[3][4] = {
{5, 37, 2, 10},

A
{27, 16, 9, 11},
{24, 22, 8, 55}

Y A M
F
};

l a is e
f . B
ro
long tableau[3][4] = {{5, 37, 2, 10}, {27, 16, 9, 11}, {24, 22, 8, 55}};

P
 A M A
e F Y
l a is
f . B
Pro
Exercice : Remplir le tableau dans une Boucle
int main()
{
long tab[5], i = 0; long valeur = 1;
while(valeur != 0 && i < 5 ){

A
tab[i] = valeur; i++;

A M
printf("1 : Ajouter un autre\n 0 : Quitter \n");

Y
scanf("%d", &valeur);

e F
}

is
for(i = 0; i < 5; i++){

B l a
printf("A l indice %d Il y a %d \n", i, *(tab + i));

.
f
}

ro
return 0;

P
}
int main(){
Tri
long tableau[] = {10, 23, 505, 8}, i = 0,j = 0, tampon;
printf("Tableau avant tri \n");
for (i = 0 ; i < 4 ; i++) printf("%ld ", tableau[i]);
printf("\n Tableau après tri \n");

A
for (i = 0 ; i < 4 ; i++) {

A M
for (j = i+1 ; j < 4 ; j++) {

Y
if(tableau[i] < tableau[j] ){

e F
tampon = tableau[j];

is
tableau[j] = tableau[i];

l a
tableau[i] = tampon;

. B
} } }

ro f
for (i = 0 ; i < 4 ; i++) printf("%ld ", tableau[i]);

P
return 0; }
 Recherche dans un Tableau en C

A M A
e F Y
l a is
f . B
Pro
 Structure : SEtudiant
matricule nom note
e1 1111 KISONGO 14
e2 1212 NGOIE WA NGOIE 10

A
e3 1112 BIDWAYA 18

Y A
e1, e2, e3 : sont appelés « Enregistrements deM
type SEtudiant »
s e F
B l a i
Matricule, nom, note : sont appelés des

ro
champs
f .
P
 Solution

A M A
e F Y
l a is
f . B
Pro
Remplir dans une Boucle Tableau des étudiants

A M A
e F Y
l a is
f . B
P ro
 Recherche avec strcmp()

A M A
e F Y
l a is
f . B
Pro
 A M A
e F Y
l a is
f . B
Pro
 Exemple

A M A
e F Y
l a is
f . B
Pro
 Tableau des étudiants

A M A
e F Y
l a is
f . B
Pro
 A M A
e F Y
l a is
f . B
Pro
 A M A
e F Y
l a is
f . B
Pro
 type
enregistrement

A M A
e F Y
l a is
f . B
Pro
 A M A
e F Y
l a is
f . B
Pro