Programmation en langage C

Prof. PAPA DIOP

[email protected]

Cours de 1ère année de Licence en Informatique

UFR Sciences et Technologies
Université de THIES
 Qu'est-ce qu'un bon programme?
Un Bon Programme ? ? :

Il doit résoudre le PROBLEME !

Efficacité -Rapidité?

INSTANTANE ! DUREE DE VIE ?

- Lisible
- Structuré

Langage C : Prof. PAPA DIOP 2

 Objectifs
 Être capable de bien programmer

 Comprendre les différentes constructions de

la programmation en C

 Savoir programmer de manière modulaire

Langage C : Prof. PAPA DIOP 3

 Qualités attendues
d'un programme
 Clarté
 Simplicité
 Efficacité
 Modularité
 Extensibilité

Langage C : Prof. PAPA DIOP 4

HISTORIQUE

Langage C : Prof. PAPA DIOP 5

 Types de base
4 types de base, les autres types seront dérivés de ceux-ci.

Type Exemples de valeur Codage en Peut être

Signification
mémoire

'a' 'A' 'z' 'Z' '\n' 'a' 'A'

1 octet signed,
char Caractère unique 'z' 'Z' '\n'
unsigned
Varie de –128 à 127
Short, long,
0 1 -1 4589 32000
int Nombre entier 2 ou 4 octets signed,
-231 à 231 +1
unsigned
Nombre réel 0.0 1.0 3.14 5.32
float 4 octets
simple -1.23

Nombre réel 0.0 1.0E–10 1.0 -

double 8 octets long
double précision 1.34567896

Langage C : Prof. PAPA DIOP 6

 FOCUS ON BOOLEAN TYPE
Vous pourrez déclarer des variables
booléennes en incluant seulement à l’en-
tête la bibliothèque stdbool.h
#include<stdbool.h>
…..
bool a ;
a=true;

Une variable booléenne ne peut prendre qu’une seule

valeur (true ou false)
Langage C : Prof. PAPA DIOP 7
 TYPE de la valeur de retour

"main" : Cela signifie "principale",

ses instructions sont exécutées.

int main(void)
{
void main(void): La fonction main ne prend
/* corps du programme*/
début aucun paramètre et ne retourne pas de valeur.
declaration des Cstes et Var ;
instruction1 ; int main(void): La fonction main retourne une
valeur entière à l'aide de l'instruction return (0
instruction2 ; si pas d’erreur).
….
int main(int argc, char *argv[]): On obtient
}
alors des programmes auxquels on peut
fin adresser des arguments au moment où on lance
le programme.
Entre accolades "{" et "}" on
mettra la succession d'actions à
réaliser.(Bloc)

Langage C : Prof. PAPA DIOP 8

 Structure d'un programme C
#include <stdio.h>
#define DEBUT -10 Directives du préprocesseur :
#define FIN 10 accès avant la compilation
#define MSG "Programme de démonstration\n"
int fonc1(int x);
int fonc2(int x); Déclaration des fonctions

void main()
{ /* début du bloc de la fonction main*/
int i; /* définition des variables locales */
Programme
i=0; principal
fonc1(i) ;
fonc2(i) ;
} /* fin du bloc de la fonction main */
int fonc1(int x) {
return x; Définitions des
}
fonctions
int fonc2(int x) {
return (x * x);
}
Langage C : Prof. PAPA DIOP 9
 Indenter = lisibilté #include <Lib1.h>
#include <Lib2.h>
Prenez l'habitude de respecter (au moins au début) les #define X 0;
règles :
int fonc1(int x);
- une accolade est seule sur sa ligne, float fonc2(char a);
- { est alignée sur le caractère de gauche de la ligne
précédente, int main(void)

- } est alignée avec l'accolade ouvrante correspondante, { /*main*/

instruction;
- après { , on commence à écrire deux caractères plus à
droite. instruction;
{
Fonctionnement : instruction;
{
- Taper et sauvegarder le programme,
instruction;
- Compiler le programme,
- Exécuter le programme. }
}
instruction;

Langage C : Prof. PAPA DIOP

} /* fin main*/ 10
 Préprocesseur
Le préprocesseur effectue un prétraitement du programme source avant qu'il soit
compilé.
Ce préprocesseur exécute des instructions particulières appelées directives.
Ces directives sont identifiées par le caractère # en tête.

Inclusion de fichiers
#include <nom-de-fichier> /* répertoire standard */
#include "nom-de-fichier" /* répertoire courant */

La gestion des fichiers (stdio.h) /* Entrees-sorties standard */

Les fonctions mathématiques (math.h)
Taille des type entiers (limits.h)
Limites des type réels (float.h)
Traitement de chaînes de caractères (string.h)
Le traitement de caractères (ctype.h)
Utilitaires généraux (stdlib.h)
Date et heure (time.h)
Langage C : Prof. PAPA DIOP 11
 1er Programme
#include <stdio.h>
#include <conio.h>
int main(void)
{

SALAMALEK
printf(" SALAM ALEK ") ;

getch() ; /* Attente d'une saisie clavier */

return 0; /* En principe un code d'erreur nul signifie "pas d'erreur". */

Langage C : Prof. PAPA DIOP 12

 La fonction d’écriture printf() :
Librairie : stdio.h. #include <stdio.h>

Syntaxe : int printf( const char *format [, arg [, arg]...]);

Description : Permet l'écriture formatée (l'écran par défaut).

Exemple :
printf("Qu'il est agreable d’utiliser printf "
"en\t C,\nlorsqu'on l'utilise \"proprement\".\n");

Résultat sur la sortie :

Qu'il est agreable d’utiliser printf en C,
lorsqu'on l'utilise "proprement".

Les caractères précédés de \ sont interprétés comme suit :

\\ : caractère \
\n : retour à la ligne
\t : tabulateur.
\" : caractère "
Langage C : Prof. PAPA DIOP \r : retour chariot 13
 Les constantes de type caractère ont une valeur entiére dans la table ASCII
char c1 = 'A',
c2 = '\x41'; /* représentation hexadécimale */

caractères nom symbole code hexa décimal

\n newline LF 10
\t tabulation HT 9
\b backspace BS 8
\r return CR 13
\f form feed FF 12
\\ backslash 5C 92
\' single quote 27 39
\" double quote 22 34

Langage C : Prof. PAPA DIOP 14

 La fonction de lecture scanf() :
Librairie : stdio.h. #include <stdio.h>

Syntaxe : int scanf(const char *format [argument, ...]);

Description : Lit à partir de stdin (clavier en principe), les différents

arguments en appliquant le format spécifié.
Exemple : scanf(" %d", &age); /* lecture de l'âge, on donne l'adresse de age */ !
Format des paramètres passés en lecture et écriture.

"%c" : lecture d'un caractère.

"%d" ou "%i" : entier signé.
"%e" : réel avec un exposant.
"%f" : réel sans exposant. "%lf" : réel double précision.
"%g" : réel avec ou sans exposant suivant les besoins.
"%G" : identique à g sauf un E à la place de e.
"%o" : le nombre est écrit en base 8.
"%s" : chaîne de caractère.
"%u" : entier non signé.
"%x" ou "%X" : entier base 16 avec respect majuscule/minuscule.
Langage C : Prof. PAPA DIOP 15
 1er Programme
#include <stdio.h>
#include <conio.h>
int main(void)
{
int age; /*déclaration d’une variable*/
printf("Je te souhaite le bon"
L’utilisation de & est indispensable avec
"jour aux TP\nEt je t"
scanf (valeur lue et donc modifiée), pas avec
"e souhaite bon trav"
printf (valeur écrite et donc non modifiée).
"ail\n");
!
printf("Quel est ton âge? ");
scanf(" %d", &age); /* lecture de l'âge, on donne l'adresse de age */
printf("\nAlors ton age est de %d ans!\n",age);

getch() ; /* Attente d'une saisie clavier */

return 0; /* En principe un code d'erreur nul signifie "pas d'erreur". */
}
Quel est ton âge ? 18
Alors ton age est de 18 ans!
Langage C : Prof. PAPA DIOP 16
 Variables : déclarations
Syntaxe : Type identificateur1, identificateur2, …,…. ;

Exemple: char c1, c2, c3;

int i, j, var_ent;

Variables : initialisations
Les variables doivent être déclarées avant leur utilisation dans un début de bloc (juste après{),
zone des déclarations:

void main(void) void main(void)

{ {
est équivalent à
char c; char c = 'A';
int i,j, k;
c = 'A'; int i=50,j, k;
i = 50; j=k=10;
j =10; = opérateur d’affectation
k=10;

Langage C : Prof. PAPA DIOP

Cette règle s'applique à tous : char, int, float ... 17
 ! scanf
Exemples entrées résultats

char c1, c2, c3;

scanf("%c%c%c",&c1,&c2,&c3);
abc c1=a c2=<espace> c3=b

scanf(" %c %c %c",&c1,&c2,&c3); c1=a c2=b c3=c

char c;
int i;
float x;

scanf("%2d %5f %c",&i,&x,&c); 12 123.567 r i=12 x=123.5 c=6

Langage C : Prof. PAPA DIOP 18

 Affichages et saisies
Librairie : stdio.h
Fonction Syntaxe Description

printf printf( const char *format [, arg [, Écriture formatée

arg]...]); : sortie standard

scanf scanf( const char *format [, arg [, Lecture formatée

arg]...]); 7 entrée standard

putchar putchar(int c); Écrire le caractère c

:

getchar getchar(); Lecture d'un caractère

getch(); <conio.h> 7
getch
puts *puts(char *s); Ecriture/Lecture d'une
*gets(char *s); chaîne de caractères,
gets terminée par \n
sprintf sprintf(char *s, char *format, arg ...); Ecrit dans la chaîne
d'adresse s.

sscanf sscanf(char *s, char *format, pointer Lit la chaîne d'adresse s.

...);

Langage C : Prof. PAPA DIOP 19

 LES DECLARATIONS DE CONSTANTES
1ere méthode: définition d'un symbole à l'aide de la directive de compilation #define.
Le compilateur ne réserve pas
Exemple: #define PI 3.14159
de place en mémoire
void main()
{
float perimetre,rayon = 8.7;
perimetre = 2*rayon*PI;
....
}

Syntaxe : #define identificateur texte(valeur) !

Les identificateurs s'écrivent
#define TAILLE 100 traditionnellement en
#define MAXI (3 * TAILLE + 5) majuscules, mais ce n'est pas
#define nom_macro(identif_p1 , ... ) texte une obligation.
#define SOMME(X,Y) X+Y
#define MULTIP(A,B) (A)*(B)

Langage C : Prof. PAPA DIOP 20

 LES DECLARATIONS DE CONSTANTES
2eme méthode : déclaration d'une variable, dont la valeur sera constante pour tout le programme.

Exemple :
void main()
{ Le compilateur réserve de
const float PI = 3.14159; la place en mémoire (ici 4 octets).
const int JOURS = 5;
float perimetre, rayon = 8.7;
perimetre = 2*rayon*PI;
.... /*ERREUR !*/ On
JOURS = 3; ! ne peut changer la valeur
.... d’une constante.
}
Langage C : Prof. PAPA DIOP 21
 Identificateurs
Les identificateurs nomment les objets C (fonctions, variables ... )

C'est une suite de lettres ou de chiffres.

Le premier caractère est obligatoirement une lettre.
Le caractère _ (souligné) est considéré comme une lettre.
Reconnaissance suivant les 31 premiers caractères.

Le C distingue les minuscules des majuscules.

Exemples :
abc, Abc, ABC sont des identificateurs valides et tous différents.

Identificateurs valides :
xx y1 somme_5 _position
Noms surface fin_de_fichier VECTEUR

Identificateurs invalides :
3eme commence par un chiffre
x#y caractère non autorisé (#)
no-commande caractère non autorisé (-)
taux change caractère non autorisé (espace)
Langage C : Prof. PAPA DIOP 22
 Un identificateur ne peut pas être un mot réservé du langage :

auto double int struct

break else long switch
case enum register typedef
char extern return union
const float short unsigned
continue for signed void
default goto sizeof volatile
do if static while

RQ : Les mots réservés du langage C

doivent être écrits en minuscules.

Langage C : Prof. PAPA DIOP 23

 Les opérateurs arithmétiques
 Le C propose les opérateurs suivants :

+ addition
- soustraction
* multiplication
/ division
% modulo (reste de la division entière )

% ne peut être utilisé qu'avec des entiers

7/2 3

7.0/2
7/2.0
7.0/2.0
 3.5

Langage C : Prof. PAPA DIOP 24

 Utiliser des opérateurs arithmétiques

Le compilateur considère le type des opérandes

pour savoir comment effectuer les opérations
k= 5/4 = 1 void main(void)
{
int i = 5, j = 4, k;
h = 5.0/4.0 = 1.25 double f = 5.0, g = 4.0, h;

k = i / j;
h = f / g;
h = 5/4 = 1.0000 h = i / j;
}

Langage C : Prof. PAPA DIOP 25

 Les opérateurs de comparaison
< plus petit
Le résultat d'une
<= plus petit ou égal expression
> plus grand logique vaut 1 si
>= plus grand ou égal elle est vraie et 0
! == égal sinon.
!= différent
Réciproquement,
Les opérateurs logiques toute valeur non !
nulle est considérée
&& et comme vraie et la
|| ou (non exclusif) valeur nulle
comme fausse.
! non

Langage C : Prof. PAPA DIOP 26

 int i;
Exemple
float f;
char c;

i = 7; f = 5.5; c = 'w';

f>5 ====> vrai (1)

(i + f) <= 1 ====> faux (0)
c == 'w‘ ====> vrai (1)
c != 'w' ====> faux (0)
c >= 10*(i + f) ====> faux (0)
(i >= 6) && (c == 'w') ====> vrai (1)
(i >= 6) || (c == 119) ====> vrai (1)

!expr1 est vrai si expr1 est faux et faux si expr1 est vrai ;
expr1&&expr2 est vrai si les deux expressions expr1 et expr2 sont vraies et
faux sinon. L'expression expr2 n'est évaluée que dans le cas où l'expression
expr1 est vraie ;

expr1 || expr2 = (1) si expr1=(1) ou expr2=(1) et faux sinon.

L'expression expr2 n'est évaluée que dans le cas où l'expression expr1
est fausse.
Langage C : Prof. PAPA DIOP 27
 Contractions d'opérateurs
 Il y a une famille d’opérateurs
+= -= *= /= %=
&= |= ^=
<<= >>=
 Pour chacun d’entre eux
expression1 op= expression2
est équivalent à:
(expression1) = (expression1) op (expression2)
a += 32; f /= 9.2; i *= j + 5;
a = a + 32; f = f / 9.2; i = i * (j + 5);
Langage C : Prof. PAPA DIOP 28
 Incrément et décrement

 C a deux opérateurs spéciaux pour incrémenter (ajouter 1)

et décrémenter (retirer 1) des variables entières
++ increment : i++ ou ++i est équivalent à i += 1 ou i = i + 1
-- decrement
 Ces opérateurs peuvent être préfixés (avant la variable) ou
postfixés (après)
int i = 5, j = 4;
“i” vaudra 6
i++;
“j” vaudra 3 --j;
++i;
“i” vaudra 7
Langage C : Prof. PAPA DIOP 29
 Préfixe et Postfixe

#include <stdio.h>

int main(void)
{
équivalent à:
int i, j = 5;
1. j++;
i = ++j;
2. i = j; !
printf("i=%d, j=%d\n", i, j);

j = 5; équivalent à:
i = j++; 1. i = j;
printf("i=%d, j=%d\n", i, j); 2. j++; !
return 0;
} i=6, j=6
i=5, j=6
Langage C : Prof. PAPA DIOP 30
 Les Conversions de types
Le langage C permet d'effectuer des opérations de conversion de type.
On utilise pour cela l'opérateur de "cast" ().
#include <stdio.h>
#include <conio.h>
void main() Conversion float -> int: 89.67 -> 89
{
Conversion int -> float: 4660 -> 4660.00
int i=0x1234, j;
char d,e; Conversion int -> char: 1234 -> 34
float r=89.67,s; Conversion float -> char: 89.67 -> 89
j = (int)r;
Pour sortir frapper une touche
s = (float)i;
d = (char)i;
e = (char)r;
printf("Conversion float -> int: %5.2f -> %d\n",r,j);
printf("Conversion int -> float: %d -> %5.2f\n",i,s);
printf("Conversion int -> char: %x -> %x\n",i,d);
printf("Conversion float -> char: %5.2f -> %d\n",r,e);
printf("Pour sortir frapper une touche ");
getch(); // pas getchar
}
Langage C : Prof. PAPA DIOP 31
 Les structures de contrôle en C

Alternative: if-else
Choix Multiple: switch-case
Itérations: for, while, do-while
Rupture de Contrôle: break, continue, return … goto

Langage C : Prof. PAPA DIOP 32

 Les structures de contrôle en C
Les décisions - if then else
if (expression booléenne vraie) if (a<b)
{ {
Pas de then en C BLOC 1 D'INSTRUCTIONS min=a;
} }
else else
Le bloc " else " { {
est optionnel. BLOC 2 D'INSTRUCTIONS min=b;
} }
* Tout ce qui est 0 ( ‘\0’ 0 0.0000 NULL ) est faux
* Tout ce qui est != de 0 ( 1 ‘0’ 0.0001 1.34 ) est vrai

if(32)
printf("ceci sera toujours affiche\n");
if(0)
printf("ceci ne sera jamais affiche\n");

Langage C : Prof. PAPA DIOP 33

 Exemples :
if (i < 10) i++;
La variable i ne sera incrémentée que si elle a une valeur inférieure à 10.

if (i == 10) i++; == et pas =

La variable i ne sera incrémentée que si elle est égale à 10.

if (!recu) printf ("rien reçu\n");

Le message "rien reçu" est affiché si recu vaut zéro.

if ((!recu) && (i < 10)) i++;

i ne sera incrémentée que si recu vaut zéro et i<10.

Si plusieurs instructions, il faut les mettre entre accolades.

if ((!recu) && (i < 10) && (n!=0) ){

i++; if(delta != 0) = if(delta)
moy = som/n;
printf(" la valeur de i =%d et moy=%f\n", i,moy) ;
} if(delta == 0) = if(!delta)
else {
printf ("erreur \n");
i = i +2; // i +=2 ;
} !
Langage C : Prof. PAPA DIOP 34
 ! Attention!
 Ne pas confondre = = (opérateur logique d’égalité)
et = (opérateur d’affectation)
#include <stdio.h>

int main(void)
{
int i = 0;

if(i = 0) /* ici affectation */

printf("i = zero\n");
else
printf(“Quand i != de zero\n");

return 0;
}
Quand i != de zero

Langage C : Prof. PAPA DIOP 35

 if emboîtés
 else est associé avec le if le plus proche

int i = 100;

if(i > 0)
if(i > 1000)
printf("i > 1000\n");
else
printf("i is reasonable\n"); i is reasonable

int i = 100;

if(i > 0) {
if(i > 1000)
printf(" i > 1000 \n");
} else
printf("i is negative\n");

Langage C : Prof. PAPA DIOP 36

 Les itérations – for
int i,j;
for( init ; test; increment) i=0
{ for (i = 0; i <3; i++) { i=1
/* corps de for */ printf ( "i = %d\n", i); i = 2
} j=5
} j=4
for(j = 5; j > 0; j- -)
printf("j = %d\n", j); j = 3
double angle; j=2
j=1
for(angle = 0.0; angle < 3.14159; angle += 0.2)
printf("sine of %.1lf is %.2lf\n",angle, sin(angle));

int i, j, k;
for( ; ; )
{ for(i = 0, j = 2, k = -1; (i < 20) &&(j==2); i++, k--)
............; /* bloc d'instructions */
............;
............;
}

est une boucle infinie (répétition infinie du bloc d'instructions).

Langage C : Prof. PAPA DIOP 37
 LA BOUCLE TANT QUE ... FAIRE ...
Boucle pré-testée
Il s'agit de l'instruction while : tant que, pas jusqu’à ce que!
tant que (expression vraie)
faire{BLOC D'INSTRUCTIONS}
Syntaxe en C:
Organigramme:
while (expression)
{
............; /* bloc d'instructions */
............;
............;
}

Le test se fait d'abord, le bloc d'instructions

n'est pas forcément exécuté.

Rq: les {} ne sont pas nécessaires lorsque le

bloc ne comporte qu'une seule instruction.

Langage C : Prof. PAPA DIOP 38

 Exemple
i=1; Intérieur 1
while(i<5) Intérieur 2
{ Intérieur 3
printf(“Intérieur %d\n",i); Intérieur 4
itération i++; Extérieur 5
}
printf("Extérieur %d\n",i);

int j = 5;
start
tant que, pas jusqu’à ce que! printf("start\n"); end
while(j == 0)
printf("j = %d\n", j--);
printf("end\n");
i=1;
while(i<5);
{ "tant que l'expression est vraie
printf(“Intérieur %d\n",i); attendre".
i++;
}

Langage C : Prof. PAPA DIOP 39

 do while = REPETER … tant que
(guarantit l’exécution au moins une fois)
bloc d' do
{
instructions ............; /* bloc d'instructions */
............;
}
while (expression);
non
condition
oui vraie

suite du programme i=1;

do
int j = 5; { i=1
do j=5 printf(“i=%d ",i);
j=4 stop
printf("j = %i\n", j--); i++;
while(j > 0); j=3 }while(i<0);
printf("stop\n"); j=2 printf("stop\n");
j=1
stop
Langage C : Prof. PAPA DIOP 40
 switch = AU CAS OU ... FAIRE ...
switch(variable de type char ou int) /* au cas où la variable vaut: */
{
case valeur1: ......; /* cette valeur1(étiquette): exécuter ce bloc d'instructions.*/
.......;
break; /* L'instruction d'échappement break;
permet de quitter la boucle ou l'aiguillage le plus proche.
*/

case valeur2:........; /* cette valeur2: exécuter ce bloc d'instructions.*/

........;
break;
.
. /* etc ...*/
.
default: .......; /* aucune des valeurs précédentes: exécuter ce bloc
........; d'instructions, pas de "break" ici.*/
}
Le bloc "default" n'est pas obligatoire. valeur1, valeur2, …. doivent être des expressions
constantes. L’instruction switch correspond à une cascade d’instructions if ...else

Langage C : Prof. PAPA DIOP 41

 Cette instruction est commode pour les "menus":

char choix; int choix;

printf("SAISIE TAPER 1\n");
printf("AFFICHAGE TAPER 2\n"); float f;
printf("POUR SORTIR TAPER S\n");
printf("\nVOTRE CHOIX: "); scanf(" %d ", &choix); switch(f) {
choix = getchar(); case 2:
switch(choix)
switch(choix) ....
{ {
case '1': .......; case 1: … switch(i) {
break; ! case 2 * j:
....
case '2': ......;
break;

case 'S': printf("\nFIN DU PROGRAMME ....");

break;

default : printf("\nCE CHOIX N'EST PAS PREVU "); /* pas de break ici */
}

Langage C : Prof. PAPA DIOP 42

 Instructions d'échappement
Pour rompre le déroulement séquentiel d'une suite d'instructions

Break;
# Continue; 8
int i, j=1; for (i = -10; i <= 10; i++)
char a; {
for (i = -10; i <= 10; i++){ if (i == 0)
continue;
while(j!=0) /* boucle infinie */ // pour éviter la division par zéro
{ printf(“ %f”, 1 / i);
a=getchar(); }
if(a= ='x')
break;
} return (expression);
} permet de sortir de la fonction qui la contient

exit (expression); La fonction est interrompu.

Si x est tapée au clavier expression : un entier indiquant le code de terminaison
du processus
Langage C : Prof. PAPA DIOP 43
goto étiquette
#include <stdio.h>
void main()
{
int i, j;
for (i=0; i < 10; i++)
for (j=0; j < 4; j++) {
if ( (i*j) == 10)
goto trouve;
else printf("i*j != 10.\n");
}
trouve:
printf("i*j =%d * %d = %d== 10.\n",i,j,i*j);
}

Langage C : Prof. PAPA DIOP 44

 ENUMERATIONS (1/3)
 En C, on définit un type énuméré en utilisant le mot-clé
enum selon la syntaxe suivante :

enum nom_type { constante1, constante2, …, constanteN };

 Exemples:
enum couleur {bleu, blanc, rouge, vert, jaune, noir} ;
enum jour {Lundi, Mardi, Mercredi, Jeudi, Vendredi, Samedi, Dimanche} ;

 Chaque constante est associée à un entier (son numéro d’ordre en

partant de 0 pour le premier). Mais on peut aussi spécifier la valeur
associée.

Langage C : Prof. PAPA DIOP 45

 ENUMERATIONS (2/3)
 Exemple:

enum jour {Lundi=1,Mardi,Mercredi=5,Jeudi,Vendredi,Samedi,Dimanche};

Mardi prend la valeur 2, Jeudi la valeur 6,…

 Les valeurs associées aux constantes ne sont pas modifiables dans le

programme.

 Après avoir défini un type énuméré, on peut l'utiliser pour déclarer une
ou plusieurs variables de ce type.

 Exemples:
enum jour j1;
enum jour j2 = Mardi;
Langage C : Prof. PAPA DIOP 46
 ENUMERATIONS (3/3)
Voici un programme qui manipule un type énuméré pour les jours de la semaine :

#include <stdio.h>
#include <conio.h>
enum Jour {lundi=1,mardi,mercredi,jeudi,vendredi,samedi,dimanche};
int main()
{
enum Jour un_jour ;
printf("Donnez un numéro de jour entre 1 et 7") ; scanf("%d", &un_jour) ;
switch(un_jour )
{
case lundi : printf("C’est Lundi"); break ;
case mardi : printf("C’est Mardi"); break ;
case mercredi : printf("C’est Mercredi"); break ;
default : printf("Ce n’est ni Lundi ni Mardi ni Mercredi");
}
getch() ;
return 0 ;
}
Langage C : Prof. PAPA DIOP 47
 TABLEAUX : Introduction
Déclaration de tableaux
 Un tableau (array) est une collection de variables de même type, appelées éléments
désignés par un identificateur unique.
 On les déclare par un type, un nom et une dimension (CONSTANTE) placée entre [ ]
 Le C alloue toujours un tableau dans une zone contigüe de la mémoire
 Une fois déclaré, on ne peut redimensionner un tableau

Exemples
int tab[4]; déclare un tableau de 4 valeurs entières tab[0] tab[1] tab[2] tab[3]
!
#define SIZE 10
int a[SIZE]; /* a est un vecteur de 10 entiers */

le compilateur réserve SIZE places en mémoire pour ranger les éléments du tableau.

float A[5] = { 10.1, 20.3, 30.5, 40.0, 50.4 };

Langage C : Prof. PAPA DIOP 48

 Accès aux éléments d’un tableau
 Les éléments sont numérotés de 0 à dim-1 !
 Il n’y a pas de vérification de bornes
void main(void) a void main(void)
{ 59 0
{
int a[6];
? 1
int i = 7; int i;
? 2
int A[6] = { 1, 2,3, 5, 7, 11 };
a[0] = 59; 2 3
a[5] = -10; for (i=0;i<6;i++)
a[i/2] = 2; ? 4
printf("%d ", A[i]);
-10 5
a[6] = 0; }
a[-1] = 5;
}

Les tableaux consomment beaucoup de place mémoire.

On a donc intérêt à les dimensionner au plus juste.
Langage C : Prof. PAPA DIOP 49
 void main()
{
const int N=10;
int t[N],i;
for (i=0;i<N;i++){
printf("Entrez t[%d]=",i);
scanf("%d",&t[i]);
}
}

Langage C : Prof. PAPA DIOP 50

 Fonctions en C
Encapsule un traitement particulier formant un tout
 Peut implémenter la notion de module en logique
 Notion de librairie
 Augmente la lisibilité d’un programme
 Réalise un objectif précis
 Améliore le débogage et la maintenance d’un programme
Son utilisation se décompose en trois phases :
 Définition de la fonction
 Déclaration de la fonction
 Appel de la fonction Déclarer une fonction
Appeler une fonction
Règles de visibilité des variables
Passage des paramètres par valeur
Fonction renvoyant une valeur au programme
Passage des paramètres par valeur et par adresse
Passage des tableaux aux fonctions

Langage C : Prof. PAPA DIOP 51

 Fonctions en C
Les principes
 En C, tout est fonction (Définition, Déclaration et Appel).
 Une fonction peut avoir autant de paramètres que l’on veut, même
aucun
(comme void main(void))
 Une fonction renvoie une valeur ou aucune.
 Les variables déclarées dans une fonction sont locales à cette fonction
 Une fonction possède un et un seul point d'entrée, mais éventuellement plusieurs points de sortie (à
l'aide du mot return).
 L'imbrication de fonctions n'est pas autorisée:
une fonction ne peut pas être déclarée à l'intérieur d'une autre fonction. Par contre, une fonction peut appeler une autre fonction. Cette
dernière doit être déclarée avant celle qui l'appelle.

Langage C : Prof. PAPA DIOP 52

 Déclarer une fonction

TYPE de la valeur de retour 3 doubles comme paramètres

int print_table(double start, double end, double step)

{
double d;
Nom de la fonction
int lines = 1;

printf("Celsius\tFarenheit\n");
for(d = start; d <= end; d += step, lines++)
printf("%.1lf\t%.1lf\n", d, d * 1.8 + 32);

return lines;
}

Valeur renvoyée
Langage C : Prof. PAPA DIOP 53
 Appeler une fonction
IMPORTANT: cette instruction spécifie comment la fonction est définie

#include <stdio.h>

int print_table(double, double, double);

void main(void)
{
int combien; Le compilateur attend des
double end = 100.0; doubles; les conversions sont
automatiques
combien = print_table(1.0,end,3);
print_table(end, 200, 15);
}
Ici, on ne tient pas compte de la valeur de retour

Langage C : Prof. PAPA DIOP 54

 float calculeFloat(float, float);
int addition();
void main(void)
{
int Val ;

Val = addition();
printf(“val = %d”, Val);
}

int addition()
{
float tmp;
tmp = calcule(2.5,3) + calcule(5,7.2);
return (int)tmp;
}

float calcule(float float1, float float2)

{
return ( (float1 + float2 ) / 2) ;
}
Langage C : Prof. PAPA DIOP 55
 Règles de visibilité des variables
Le C est un language structuré en blocs { } , les variables ne
peuvent être utilisées que là où elles sont déclarées
void func(int x);
int glo=0; // variable globale
void main(void)
{ Le compilateur ne
int i = 5, j, k = 2; //lacales à main connaît pas d
float f = 2.8, g;
d = 3.7;
func (i);
}
void func(int v)
{ Le compilateur ne
double d, e = 0.0, f =v; //lacales à func connaît pas i et g
i++; g--;glo++;
f = 0.0; C’est le f local qui est
} utilisé

Langage C : Prof. PAPA DIOP 56

 Passage des paramètres par valeur

* Quand une fonction est appelée, ses paramètres sont copiés

(passage par valeurs)

* La fonction travaille donc sur des copies des paramètres et

ne peut donc les modifier

* En C, le passage des paramètres par référence se fait en

utilisant des pointeurs (voir plus loin)

* scanf() travaille avec pointeur. C'est le pourquoi du &

Langage C : Prof. PAPA DIOP 57

 Passage des paramètres par valeur
#include <stdio.h>

void change(int v);

void main(void)
{
int var = 5;

change(var); change: v = 500

main: var = 5
printf("main: var = %d\n", var);
}

void change(int v)
{
v *= 100;
printf("change: v = %d\n", v);
}

Langage C : Prof. PAPA DIOP 58

 FONCTION RENVOYANT UNE VALEUR AU
PROGRAMME
#include <stdio.h>

int change(int v);

void main(void){
int var = 5;
int valeur;
valeur = change(var);
change: v =
printf("main: var = %d\n", var); main: var =
printf("main: valeur = %d\n", valeur); main: valeur =
}

int change(int v)
{
v *= 100;
printf("change: v = %d\n", v);
return (v+1);
}

Langage C : Prof. PAPA DIOP 59

 Une fonction se termine et « rend la main » au code appelant lorsque son
exécution rencontre l’instruction : return expression; ou return;

#include <stdio.h>

int return_Val(int v);

void main(void){
int var = 5;
int valeur;
valeur = return_Val(var);
return_Val : rien
printf("main: var = %d\n", var); main: var =
printf("main: valeur = %d\n", valeur); main: valeur =
}

int return_Val(int v)
{
if (v == 10) return (2*v);
else return (3*v);
}

Langage C : Prof. PAPA DIOP 60

 int max (int a, int b) {
if (a > b) return a ;
else return b ;
}
int min (int a, int b) {
if (a < b) return a ;
else return b ;
}
int difference (int a, int b, int c) {
return (max (a, max(b,c)) - min (a, min (b, c))) ;
}
void main ()
{
printf ("%d", difference (10, 4, 7)) ;
}
Langage C : Prof. PAPA DIOP 61
 Une fonction est dite récursive, dès lors ou elle se fait appel pour
calculer une sous partie de la valeur finale qu'elle retournera.
#include <stdio.h>
int fact(int n);
int return_Val(int v);

void main(void){
int var = 5, int valeur;
valeur = return_Val(var);
printf("main: var = %d\n", var);
printf("main: valeur = %d\n", valeur); return_Val : rien
} main: var =
main: valeur =
int fact(int n) {
return (n<2?1:((int)n*fact(n-1));
}
(0)=0*fact(-1)
int return_Val(int v)
{ int temp=1;
if (v == 10) return (2*v); while(n>1) temp*=n--;
else return fact(v);
}

Langage C : Prof. PAPA DIOP 62

L’opérateur ternaire “?:”
return(n<2?1:((int)n*fact(n-1));

Cet opérateur s’écrit: (condition) ? (instruction_1) : (instruction_2)

si la condition est vérifiée le bloc “instruction_1” est exécuté, sinon c’est le
bloc “instruction_2” qui l’est.

if (n<2 ) {
return 1;
} return(n<2?1:((int)n*fact(n-1));
else {
return ((int)n*fact(n-1));
}

Langage C : Prof. PAPA DIOP 63

 int fact( int n) {
if (n < 1) return 1;
else return ( n * fact(n-1) );
}

void hanoi(int n, int a, int b){

int c ;
…
if (n == 1) move(a,b);
else {
hanoi(n-1, a, c);
move (a, b);
hanoi(n-1, c, b);
}
}

Langage C : Prof. PAPA DIOP 64

 Passer des tableaux aux fonctions
 Les tableaux peuvent être passés comme paramètres d'une fonction.
 Ils ne peuvent pas être retournés comme résultat d'une fonction. !
 La longueur du tableau ne doit pas être définie à la déclaration de la fonction.
 Un tableau peut être modifié dans une fonction. Il est passé par référence
(adresse) et non par valeur.
#include <stdio.h>
void somme(int x[], int n); p avant somme p après somme
void main(void){
int i; 1 1
int p[6] = { 1, 2,3, 5, 7, 11 };
somme(p, 6); 2 3
for (i=0;i<6;i++) 3 5
printf("%d ", p[i]);
} 5 8

7 12
void somme(int a[], int n){
11 18
int i;
for(i = n-1; i >0 ; i--)
a[i] += a[i-1];
}
Langage C : Prof. PAPA DIOP 65
 Exemple: transposition d'une matrice
void transpose ( float a[][20], int m, int n);

void main(void)
{float matrice [100][20]; /* matrice (100,20) */
/*…*/
transpose (matrice, 3, 2);
}

void transpose ( float a[][20], int m, int n)

{ int i,j;
float tmp;
for (i=0;i<m;i++)
for(j=0;j<i;j++) {
tmp = a[i][j];
a[i][j]=a[j][i];
a[j][i]=tmp;
}
}
}

Langage C : Prof. PAPA DIOP 66

 TP1
Écrire un programme en C qui range au maximum (taille
Nmax ) 20 nombres entiers saisis au clavier dans un
tableau. Il doit gèrer en boucle le menu de choix suivant :

A- Saisie et affichage
B- Moyenne
C- Suppression du Max et affichage
D- Suppression du Min et affichage
E- Ajout d’un entier à une position donnée
Q- Quitter

Langage C : Prof. PAPA DIOP 67

Le point A sera traité par deux fonctions :
Saisie : la saisie au clavier des entiers et leur rangement dans le tableau.
Dans cette fonction on demandera le nombre d’éléments (NE<= Nmax)à saisire.
Affichage : affichage des données.

Le point B sera traité par une fonction :

Moyenne : fonction de calcul de la moyenne du tableau (avec affichage du résultat).

Le point C sera traité par trois fonctions :

Max_elem : une fonction qui retourne la position du maximum des valeurs du tableau.
Supprimer : supprime le Max du tableau.
Affichage : affichage des données.

Le point D sera traité par trois fonctions :

Min_elem : une fonction qui retourne la position du minimum des valeurs du tableau.
Supprimer : supprime le Mix du tableau.
Affichage : affichage des données.

Le point E sera traité par deux fonctions :

Ajout : c’est une fonction où on demande à l’utilisateur d’introduire l’entier et la position.
Puis vous insérer l’entier dans le tableau à la position indiquée.
Affichage : affichage des données.
Langage C : Prof. PAPA DIOP 68
 Strings : Chaînes de caractères
 Le C n’a pas de type string, on utilise donc des tableaux de char.

 Un caractère spécial, le caractère “null”, marque la fin du string (à ne pas

confondre avec le pointeur NULL ).

 Ce caractère est noté ‘\0’, de code ASCII 0 .

 Ce caractère est soit ajouté automatiquement par le compilateur, soit à

introduire par le programmeur, dépendant des fonctions utilisées.
char first_name[5] ={ 'J','o','h','n','\0'}; 'J' 'o' 'h' 'n' 0

char last_name[6] ="Minor"; 'M' 'i' 'n' 'o' 'r' 0

char other[] = "Tony Bloot"; 'T' 'o' 'n' 'y' 32 'B' 'l' ‘o' ‘o' 't' 0

char characters[7] = "No null"; 'N' 'o' 32 'n' 'u' 'l' 'l'

Pas de ‘\0’
Langage C : Prof. PAPA DIOP 69
 Entrées/Sorties Standards
E F G H
• getchar() : 7 lire un caractère sur entrée standard (valeur -1 = EOF = fin)

• putchar() : : écrire un caractère sur sortie standard

Exemple: Copie de Input sur Output.

main(){
char c; main(){
c = getchar(); char c;
while (c != EOF) { while ( (c=getchar())!= EOF)
putchar(c); putchar(c);
c = getchar(); }
}
}

• Fichiers stdin et stdout: Tout programme lit ou écrit sur ces fichiers (défaut clavier et écran).

Langage C : Prof. PAPA DIOP 70

Affichage à l'écran des strings
 Soit caractère par caractère, avec le format “%c” ou putchar,
 ou, plus simplement, avec le format “%s” ou puts .

char last_name[6] = "Minor"; Minor 'M' 'i' 'n' 'o' 'r' 0

int i = 0;
last_name[3] = ‘\0’; Min
while(last_name[i] != '\0')
printf("%c", last_name[i++]);
printf("\n");
} printf("%s\n", last_name);
puts(last_name);

Langage C : Prof. PAPA DIOP 71

 Saisie des strings
char texte[30];
printf("ENTRER UN TEXTE: ");
scanf("%s", texte); //est équivalent à gets(texte);

Une chaîne : pas de symbole &. On utilisera de préférence la fonction gets non
!
formatée.

Si text = un deux   entre scanf et gets?

Langage C : Prof. PAPA DIOP 72

 RQ:
scanf ne permet pas la saisie d'une chaîne comportant des espaces: les caractères saisis à partir de
l'espace ne sont pas pris en compte. Pour saisir une chaîne de type "il fait beau", il faut utiliser
gets.

#include <stdio.h>
#include <string.h>
Affectation de strings :
Les strings peuvent être void main(void) {
initialisés avec “=”, char who[] = "Tony Bloot";
mais pas affectés avec “=”
(ce sont des tableaux!) who = "John Minor";
strcpy(who, "John Minor");
}

Langage C : Prof. PAPA DIOP 73

Fonctions permettant la manipulation des chaînes
string.h ou stdlib.h

void *strcat(char *chaine1,char *chaine2)

//Concatène les 2 chaînes, résultat dans chaine1.
void *strcpy(char *chaine1,char *chaine2)
//Copie la chaine2 dans chaine1. + '\0‘
void *strncpy(char *chaine1,char *chaine2, NCmax)
// idem strcpy mais limite la copie au nombre de caractères NCmax.
int strcmp(char *chaine1,char *chaine2)
//Compare les chaînes de caractères chaine1 et chaine2,
renvoie un nombre:
- positif si la chaîne1 est supérieure à la chaine2 (au sens de l'ordre alphabétique)
- négatif si la chaîne1 est inférieure à la chaîne2
- nul si les chaînes sont identiques.
int strlen(char *chaine)
// renvoie la longueur de la chaine ('\0' non comptabilisé).
int atoi(const char *s)
// convertit l'argument s en un int,
Langage C : Prof. PAPA DIOP 74
Exemple: #include <string.h>
#include <ctype.h> // toupper
#define EOL ‘\n’

void main(void)
{
int L,i=0;
char s[9] = "midi", u[11] = "avant", v[10] = "soir";
char text[80]; text[i] = getchar();
while ( text[i] != EOL ) {
While ( (text[i] = getchar() ) != EOL ) i++; i++;
text[i] = getchar();
puts(text);
}
L = strlen(s); /* L = 4 */
for (i=0;i<L;i++) {
putchar(toupper(s[i])); /* M, I, D,I */
}

strcat(u,"-"); /* u devient "avant-" */

strcat(u , s); /* u devient "avant-midi" */
if (strcmp (u, s) >=0 ) /* "avant-midi" < "midi" */
printf ("il y a une erreur\n");
else {
printf("%s\n", u); /* avant-midi */
strcpy (u, v);
printf("%s\n", u); /* soir */
}
}

Langage C : Prof. PAPA DIOP 75

 Passage des paramètres par valeur et par adresse
#include <stdio.h> PASSAGE DES PARAMETRES

void ech(int x,int y){ PAR VALEUR

int tampon;
tampon = x;
x = y; a et b: variables locales à main(). La fonction ech ne peut
y = tampon; donc pas modifier leur valeur. On le fait donc en passant par
} l'adresse de ces variables.

void main() {
int a = 5 , b = 8;
ech(a,b);
Syntaxe qui conduit à une erreur
printf(“ a=%d\n ”, a) ;
a=5
printf(“ b=%d\n ”, b) ;
} b=8

Langage C : Prof. PAPA DIOP 76

 ' Les Pointeurs en C '
 La déclaration de pointeurs
 Valeurs pointées et adresses
 Passage de paramètres de fonction par référence
 Pointeurs et tableaux

Langage C : Prof. PAPA DIOP 77

 Les pointeurs, c'est quoi?
Un pointeur est une variable particulière, dont la
valeur est l'adresse d'une autre variable.
 Pointeur p: valeur 5A0F3 (adresse hexadécimale)
 Adresse 5A0F3: valeur 17 (correspondant à la
valeur d'un entier i)
En accédant à cette adresse, on peut accéder indirectement à la variable et donc la modifier.

i=17
5A0F3 17

p=5A0F3 p i
Un pointeur est une adresse mémoire. On dit que le
pointeur p pointe vers i, puisque p pointe vers
l’emplacement mémoire où est enregistrée i.
Langage C : Prof. PAPA DIOP 78
 Les pointeurs: pourquoi ?
 Les pointeurs sont nécessaires pour:

 effectuer les appels par référence (i.e. écrire des

fonctions qui modifient certains de leurs paramètres)

 manipuler des structures de données dynamiques (liste,

pile, arbre,…)

 allouer dynamiquement de la place mémoire

Langage C : Prof. PAPA DIOP 79

 Déclaration de Pointeurs
Le symbole * est utilisé entre le type et le nom du pointeur
 Déclaration d’un entier: int i;

 Déclaration d’un pointeur vers un entier: int *p;

Exemples de déclarations de pointeurs
int *pi; /* pi est un pointeur vers un int
*pi désigne le contenu de l'adresse */
float *pf; /* pf est un pointeur vers un float */

char c, d, *pc; /* c et d sont des char*/

/* pc est un pointeur vers un char */
double *pd, e, f; /* pd est un pointeur vers un double*/
/* e et f sont des doubles */
double **tab; /* tab est un pointeur pointant sur un pointeur qui
pointe sur un flottant double */

Langage C : Prof. PAPA DIOP 80

 Opérateurs unaires pour manipuler les pointeurs,
& (adresse de) et * (contenu)
Exemple: int i = 8;
printf("VOICI i: %d\n",i);
printf("VOICI SON ADRESSE EN HEXADECIMAL: %p\n",&i);

nom_de_Pointeur = &nom_de_variable
void main(void)
p c
{
0x1132 'a'
char c = 'a', d = 'z';
0x1132
char *p;
p d
0x91A2 'z'
*p = c; 0x91A2
p = &c;
printf("%c\n", *p);
p = &d; L’opérateur * (“valeur pointée par”)
printf("%c\n", *p);
} a
z
Langage C : Prof. PAPA DIOP 81
 #include <stdio.h>
void main() {
int *p, x, y;
p = &x; /* p pointe sur x */
x = 10; /* x vaut 10 */
y = *p - 1; printf(" y= *p - 1 =? = %d\n" , y); y vaut ?
*p += 1; printf(" *p += 1 =? *p = x= ? = %d %d\n" , *p, x); x vaut ?
(*p)++; printf(" (*p)++ =? *p = x= ? = %d %d alors y=%d \n" , *p, x, y);
incrémente aussi de 1 la variable pointée par p, donc x vaut ??.
y vaut 9

*p=0; printf(" *p=0 x=? = %d\n" , x);

comme p pointe sur x, maintenant x vaut ?
*p++; *p=20; printf(" *p++ x=? = %d\n" , x);
} comme p ne pointe plus sur x, x vaut tjr ?
Langage C : Prof. PAPA DIOP 82
 Utiliser des pointeurs
 On peut donc accéder aux éléments par pointeurs en
faisant des calculs d’adresses (addition ou soustraction)

long v[6] = { 1,2,

3,4,5,6 };
long *p;
p += 4
p++
p = v;
printf("%ld\n", *p); 1
p
p++; 2
printf("%ld\n", *p); 6 1000 1 2 3 4 5 6
v
p += 4; 1000 1008 1016
printf("%ld\n", *p); 1004 1012 1020

Langage C : Prof. PAPA DIOP 83

 * et ++
*p++ signifie:
*p++ trouver la valeur pointée
*p++ passer à l’adresse suivante !
(*p)++ signifie:
(*p)++ trouver la valeur pointée
(*p)++ incrémenter cette valeur (sans
changer le pointeur)
*++p signifie:
*++p incrémenter d’abord le pointeur
*++p trouver la valeur pointée

Langage C : Prof. PAPA DIOP 84

 Passage des paramètres par valeur et par adresse
Syntaxe qui conduit à une erreur: a et b: variables Syntaxe correcte:
locales à main(). La
#include <stdio.h> #include <stdio.h>
fonction ech ne
void ech(int x,int y) peut donc pas void ech(int *x,int *y)
{ modifier leur {
int tampon; valeur. On le fait int tampon;
tampon = x; donc en passant par tampon = *x;
x = y; l'adresse de ces *x = *y;
y = tampon; variables. *y = tampon;
} }

void main() void main()

{ {
int a = 5 , b = 8; int a = 5 , b = 8 ;
ech(a,b); ech(&a,&b);
printf(“ a=%d\n ”, a) ; a=? printf(“ a=%d\n ”, a) ; a=?
printf(“ b=%d\n ”, b) ;
b=?
printf(“ b=%d\n ”, b) ; b=?
} }
PASSAGE DES PARAMETRES PASSAGE DES PARAMETRES
PAR VALEUR PAR ADRESSE
Langage C : Prof. PAPA DIOP 85
 Passage de paramètres de fonction
par référence ou adresse
 Quand on veut modifier la valeur d'un paramètre
dans une fonction, il faut passer ce paramètre par
référence ou adresse

 En C, cela se fait par pointeur

void change ( int *a, int *b)
{
int tmp;
tmp = *a;
*a = *b;
*b = tmp;
}

Langage C : Prof. PAPA DIOP 86

 Appel des fonctions par référence
#include <stdio.h>
void change(int* p);
void main(void)
{
int var = 5;
change(&var);
printf("main: var = %d\n",var);
} !
void change(int* p)
{
*p *= 100;
printf("change: *p = %d\n",*p);
}
change: *p = 500
main: var = 500

Langage C : Prof. PAPA DIOP 87

 #include <stdio.h>
void somme(int , int , int *);
int modif(int , int *, int *);
void main(){
int a, b, c;
a = 2; b = 8;
somme(a, b, &c);
Somme de a=? et b=? : ?
printf("Somme de a=%d et b=%d : %d\n",a, b, c);
a = modif(a, &b, &c);
printf(" Modif : a=%d , b=%d et c= %d\n",a, b, c);
}
Modif : a=?, b=? et c= ?
void somme(int x, int y, int *z){
*z = x + y;
}
int modif(int x, int *y, int *z){
x *= 2; *y= x+ *y; *z= 5;
return x;
}
Langage C : Prof. PAPA DIOP 88
 Identification des tableaux et pointeurs
 En C, le nom d’un tableau représente l’adresse de sa
composante 0, donc a == &a[0]
 C'est pour cela que les tableaux passés comme paramètres
dans une fonction sont modifiables

Passer des tableaux aux fonctions

 Pour le compilateur, un tableau comme argument de fonction,
c’est un pointeur vers sa composante 0 (à la réservation mémoire près).
 La fonction peut donc modifier n’importe quel élément (passage
par référence)
 Le paramètre peut soit être déclaré comme tableau, soit comme
pointeur
int add_elements(int a[], int size) int add_elements(int *p, int size)
{ {
Langage C : Prof. PAPA DIOP 89
 Exemple
#include <stdio.h> Tab Tab
void sum(long [], int); 1 29
int main(void)
{ 2 2
long Tab[6] = { 1, 2, 3 3
3, 5, 7, 11 };
5 5
sum(Tab, 6);
printf("%ld\n", Tab[0]); 7 7
return 0;
11 11
}
a
void sum(long a[], int sz)
{ sz 6
int i;
long total = 0;
for(i = 0; i < sz; i++)
total += a[i];
a[0] = total;
}

Langage C : Prof. PAPA DIOP 90

 Utiliser des pointeurs - exemple
#include <stdio.h>
long sum(long*, int);
Tab Tab
int main(void)
1 1000 1
{
long Tab[6] = { 1, 2, 2 1004 2
3, 5, 7, 11 };
3 1008 3
printf("%ld\n", sum(Tab, 6));
5 1012 5
return 0;
} 7 1016 7
long sum(long *p, int sz) 11 1020 11
{
long *end = p + sz; 1024
long total = 0;
p
while(p < end) 1000
total += *p++; end 1024
return total;
}

Langage C : Prof. PAPA DIOP 91

 Quelle notation?
 A[0] est équivalent à *A
 A[i] est équivalent à *(A + i)
 &A[0] est équivalent à A
short a[8] = { 10, 20, 30, 40, 50, 60, 70, 80 };
short *p = a;

printf("%d\n", a[3]); 40
printf("%d\n", *(a + 3)); 40
printf("%d\n", *(p + 3)); 40
printf("%d\n", p[3]); 40

p a
1000 10 20 30 40 50 60 70 80
1000 1004 1008 1012
1002 1006 1010 1014

Langage C : Prof. PAPA DIOP 92

 SCANF
Pour saisir un caractère ou un nombre
char c;
float Tab[10], X[5][7]; // *Tab,(*X)[7]
printf("TAPER UNE LETTRE: ");
scanf("%c",&c);
scanf("%f",&Tab[5]);

On saisit ici le contenu de l'adresse &c c'est-à-dire le caractère c

lui-même.

pointeur
char *adr;
printf("TAPER UNE LETTRE: ");
scanf("%c",adr);

On saisit ici le contenu de l'adresse adr.

Langage C : Prof. PAPA DIOP 93
float x[dim]; réserve un espace de stockage pour dim éléments
x[0] stocke l'adresse du premier élément.
#include <stdio.h>
#include <stdlib.h>
float *x; ne réserve que le seul
void main()
espace destiné au pointeur x, {
AUCUN espace n'est réservé char *texte;
pour une ou plusieurs variables. float *adr1,*adr2;

adr1 = (float*)malloc(4*sizeof(float));
La réservation d'espace est à la adr2 = (float*)malloc(10*sizeof(float));
charge du programmeur qui doit texte = (char*)malloc(10);
le faire de façon explicite, en
utilisant les fonctions standard *adr1 = -37.28;
*adr2 = 123.67;
malloc(), … qui sont
printf("adr1 = %p adr2 = %p r1 = %f
prototypées dans <stdlib.h> et r2 = %f\n",adr1,adr2,*adr1,*adr2);
<alloc.h> free(adr1); // Libération de la mémoire
free(adr2);
free(texte);
}
Langage C : Prof. PAPA DIOP 94
 sizeof
void main()
{
int i;
char c;
caractère : 1
float f;
entier : 2 ou 4
double d;
réel : 4
printf (‘’caractère : %d \n ‘’, sizeof c);
double : 8
printf (‘’entier : %d \n ‘’, sizeof i);
printf (‘’réel : %d \n ‘’, sizeof f);
printf (‘’double : %d \n ‘’, sizeof d);
}

Langage C : Prof. PAPA DIOP 95

EXP : Création d’un tableau de taille quelconque

#include <stdio.h> // pour la fonction printf()

#include <stdlib.h> // pour la fonction malloc()

void main(){
int i , dim; // compteur et taille du tableau
long* tableau; // pointeur pour stocker l’adresse du tableau

scanf (“%d”, &dim); // saisie par l'utilisateur de la taille du tableau

tableau = (long*) malloc(dim * sizeof(long)); //allocation (dynamique) du tableau

// remplissage du tableau, on utilise les indices 0 à (dim -1)

for (i = 0; i < dim; i++)
tableau[i] = i;

// affichage du contenu du tableau

for (i = 0; i < dim; i++)
printf("%ld\n", tableau[i]);

// destruction du tableau : libération de la mémoire réservée

free(tableau);
}

Langage C : Prof. PAPA DIOP 96

 La mémoire dynamique varie en cours d'exécution, et peut n'être pas
suffisante pour allouer les variables, provoquant le plantage du programme.
Il faut donc tester le retour des fonctions d'allocation et traiter les erreurs.

Exemple:

#define BUFSIZE 100

long *var;
if ( !(var = (long *) malloc(BUFSIZE * sizeof(long))) )
// Si échec de réservation de BUFSIZE emplacement de type long ( )  0
{
fprintf(stderr, "ERREUR espace mémoire insuffisant !\n");
exit (1); // fin anticipée du programme ; code de retour 1
}
else { // le programme continue
}

L'espace alloué doit être libéré par free(), dont l'argument

est un pointeur réservé dynamiquement. free(var);
Langage C : Prof. PAPA DIOP 97
char * malloc( unsigned taille);
réserve taille octets, sans initialisation de l'espace. Retourne un pointeur sur
une zone de taille octets.

char * calloc( unsigned nombre, unsigned taille);

réserve nombre éléments de taille octets chacun ; l'espace est initialisé à 0.
#define alloue(nb,type) (type *)calloc(nb,sizeof(type))
char *s;
s = alloue(250,char); // réserve 250 octets initialisés à '\0'

void * realloc( void *block, unsigned taille);

modifie la taille affectée au bloc de mémoire fourni par un précédent appel
à malloc() ou calloc().

void free( void *block);

libére le bloc mémoire pointé par un précédent appel à malloc(), calloc() ou
realloc().

Valable pour réserver de l'espace pour les autres types de données int, float, …
Elles retournent le pointeur NULL (0) si l'espace disponible est insuffisant.
Langage C : Prof. PAPA DIOP 98
 Structures en C
 Concepts
 Créer un type de structure
 Créer une instance de structure
 Initialiser une instance
 Accéder aux membres d’une instance
 Passer les structures comme paramètres
 Listes chaînées

Langage C : Prof. PAPA DIOP 99

 Concepts
 Une structure est une collection de plusieurs variables (champs) groupées
ensemble pour un traitement commode
 Les variables d’une structure sont appelées membres et peuvent être de
n’importe quel type, par exemple des tableaux, des pointeurs ou d’autres
structures
struct Membre
{
char nom[80];
char adresse[200];
int *numero;
float amende[10];
Les étapes sont: };
 déclarer le type de la structure
 utiliser ce type pour créer autant d’instances que
désirées
 Accéder les membres des instances

Langage C : Prof. PAPA DIOP 100

 Déclarer les structures
 Les structures sont définies en utilisant
le mot-clé struct struct Membre
struct Date {
char nom[80];
{
char adresse[200];
int jour; int numero;
int mois; float amende[10];
! int an; struct Date emprunt;
struct Date creation;
}; };
struct Livre
{ struct Pret
{
char titre[80]; struct Livre b;
char auteur[80]; struct Date due;
struct Membre *who;
float prix; };
};
Langage C : Prof. PAPA DIOP 101
 Déclarer des instances
 Une fois la structure définie, les
instances peuvent être déclarées
 Par abus de langage, on appellera
structure une instance de structure
struct Date
{
int jour;
int mois;
int an;
} hier, demain; Déclaration
avant ‘;’ .
struct Date paques;
struct Date semaine[7];
Initialisation .
struct Date nouvel_an = { 1, 1, 2001 };
Langage C : Prof. PAPA DIOP 102
 Des structures dans des structures
struct Date
{
int jour;
int mois;
struct Membre
int an;
{
};
char nom[80];
char adresse[200];
int numero;
float amende[10];
struct Date emprunt;
struct Date creation;
};

struct Membre m={

"Arthur Dupont",
”rue de Houdain, 9, 7000 Mons",
42,
{ 0.0 },
{ 0, 0, 0 },
{ 5, 2, 2001 }
};
Langage C : Prof. PAPA DIOP 103
 Accéder aux membres d’une
structure
 Les membres sont accédés par le nom de l’instance,
suivi de . , suivi du nom du membre

struct Membre m;

printf("nom = %s\n", m.nom);

printf(”numéro de membre = %d\n", m.numero);

printf(”amendes: ");
for(i = 0; (i < 10) && (m.amende[i] > 0.0); i++)
printf("%.2f Euros", m.amende[i]);

printf("\nDate d’emprunt %d/%d/%d\n", m.emprunt.jour,

m.emprunt.mois, m.emprunt.an);

Langage C : Prof. PAPA DIOP 104

 Différence entre tableaux et
structures
. Arrays Structures
Nom pointeur La structure
élément 0

passage aux fonctions pointeur valeur /pointeur

retour de fonctions interdit valeur /pointeur

assignation interdit possible

Langage C : Prof. PAPA DIOP 105

 Assignation des structures

 L’opération d’affectation = peut se faire avec

des structures
 Tous les membres de la structure sont copiés
(aussi les tableaux et les sous-structures)
struct Membre m = {
"Arthur Dupont",
.....
};

struct Membre temp;

temp = m;
Langage C : Prof. PAPA DIOP 106
 Passer des structures comme
paramètres de fonction
 Une structure peut être passée, comme une autre
variable, par valeur ou par adresse
 Passer par valeur n’est pas toujours efficace
(recopiage à l’entrée)
 Passer par adresse ne nécessite pas de recopiage
void Par_valeur(struct Membre m);
void Par_reference(struct Membre *m);

Par_valeur(m);
Par_reference(&m);
Langage C : Prof. PAPA DIOP 107
 Quand la structure est un pointeur !
Utiliser p->name
 L’écriture p->name est synonyme de (*p)->name,
! où p est un pointeur vers une structure

void affiche_membre (struct Membre *p)

{
printf("nom = %s\n", p->nom);
printf("adresse = %s\n", p->adresse);
printf(”numéro de membre = %d\n", p->numero);

printf("\nDate d’affiliation %d/%d/%d\n",

p->creation.jour, p->creation.mois, p->creation.an);
}
Langage C : Prof. PAPA DIOP 108
 Retour de structures dans une fonction

 Par valeur (recopiage) ou par référence

struct Complex add(struct Complex a, struct Complex b)

{
struct Complex result = a;
result.real_part += b.real_part;
result.imag_part += b.imag_part;

return result;
}

struct Complex c1 = { 1.0, 1.1 };

struct Complex c2 = { 2.0, 2.1 };
struct Complex c3;

c3 = add(c1, c2); /* c3 = c1 + c2 */
Langage C : Prof. PAPA DIOP 109
 TP
Enoncé
Ecrire un programme permettant de :

Constituer un tableau de 20 Enseignants max(NE_max). La structure est la suivante :

struct {
char nom_pren[40]; // nom+pren
char nom[20];
char pren[20];
int NH[NM_max] ; // NM_max=3 : nbre d’heures pr NM_max matières
}

Le programme doit gérer en boucle le menu de choix suivant:

1- Saisie et affichage
2- Construction et affichage
3- Modifier et affichage
4- Tri et affichage
5- Quitter
Langage C : Prof. PAPA DIOP 110
 Tri à bulles
while(???){
for j = 0 to …. {
if tab[j] > tab[j+1] {
<on échange tab[j] et tab[j+1]>
}
} 0 1 2 3 4 5 6 j
} 2 6 4 8 12 13 0 tab[j]
6 2
6 4 2 tab[j] < tab[j+1]
6 4 8 2
6 4 8 12 2 ……

13 12 8 6 4 2 0 6 4 8 12 13 2 0

Langage C : Prof. PAPA DIOP 111

 Gestion des fichiers en C
Elle est assurée par la librairie standard <stdio.h> via un
ensemble de fonctions commençant par “f”
 Avant de manipuler un fichier, il faut lui associer un
descripteur (pointeur vers la structure fichier)
 Il y a 3 descripteurs automatiquement ouvert par tout
programme C, stdin, stdout et stderr
 stdin (standard input) est connecté au clavier. On peut y
lire
 stdout (standard output) et stderr (standard error) sont
reliés au moniteur. On peut y écrire.
!
FILE *f;
/*déclare un descripteur f de fichier*/
Langage C : Prof. PAPA DIOP 112
 Ouvrir et fermer des fichiers
Les fichiers sont ouverts avec la fonction fopen
ils sont fermés avec la fonction fclose
FILE* fopen(const char* name, const char* mode);
int fclose (FILE *f);
#include <stdio.h>
void main(void)
{
FILE* in;
FILE* out;
FILE* append;
in = fopen("autoexec.bat", "r");
out = fopen("autoexec.bak", "w");
append = fopen("config.sys", "a");
/* … */
fclose(in);
fclose(out);
fclose(append);
}
Langage C : Prof. PAPA DIOP 113
 Lecture et écriture sur fichier
Fonctions de lecture

int fscanf(FILE* stream, const char* format, ...);

int fgetc(FILE* stream);
char* fgets(char* buffer, int size, FILE* stream);

Fonctions d’écriture
int fprintf(FILE* stream, const char* format, ...);
int fputc(int ch, FILE* stream);
int fputs(const char* buffer, FILE* stream);
int feof(FILE *f); /*renvoie une valeur non nulle si fin de fichier*/

Langage C : Prof. PAPA DIOP 114

 Exemple d’écriture (lecture) de fichier
#include <stdio.h> #include <stdio.h>
void sauvegarde( char titre[], int n, void main(void)
float x[], int ind [] ) {
char titre[81];
{
float x[10];
int i=0; int ind[10], i=0;
FILE *f; FILE *f;
f = fopen(“monfichier.dat”,”w”); f = fopen(“monfichier.dat”,”r”);
if (f !=NULL){ if (f!= NULL) {
fprintf(f,”%s\n”,titre); fgets(titre,80,f);
for (i=0; i < n; i++ ) { while(!feof(f)) {
fprintf(f,”%f %d\n”, x[i],ind[i]); fscanf(f,”%f %d”,&x[i],&ind[i]);
i++;
} Mon titre }
} }
3.0 1
fclose(f); fclose(f);
} 4.5 2
}
7.3 3

La constante NULL (définie comme 0 dans stdio.h) réfère à une adresse non définie
Langage C : Prof. PAPA DIOP 115
 Compilation Séparée et édition de Lien

Un programme C est un ensemble de fonctions dans un ou plusieurs fichiers.

Fichier PP.c Fichier PP.c Fichier SP.c

main(){ main(){ g(){
…
appelle f()
… …
… appelle f() }
} …
f(){ }
appelle g()… f(){
} appelle g()…
g(){ }
…
}

Cas I Cas II

Langage C : Prof. PAPA DIOP 116

 Structure d'un programme C
#include <stdio.h>
#define DEBUT -10 Directives du préprocesseur :
#define FIN 10 accès avant la compilation
#define MSG "Programme de démonstration\n"
int fonc1(int x);
int fonc2(int x); Déclaration des fonctions

void main()
{ /* début du bloc de la fonction main*/
int i; /* définition des variables locales */
Programme
i=0; principal
fonc1(i) ;
fonc2(i) ;
} /* fin du bloc de la fonction main */
int fonc1(int x) {
return x; Définitions des
}
fonctions
int fonc2(int x) {
return (x * x);
}
Langage C : Prof. PAPA DIOP 117
 Structure d'un programme C
#include <stdio.h>
#define DEBUT -10
#define FIN 10
#define MSG "Programme de démonstration\n" Fichier.h
int fonc1(int x);
int fonc2(int x);

#include ‘’Fichier.h’’
void main()
{ /* début du bloc de la fonction main*/
int i; /* définition des variables locales */
Programme
i=0; principal
fonc1(i) ;
fonc2(i) ;
} /* fin du bloc de la fonction main */
int fonc1(int x) {
return x; Définitions des
}
fonctions
int fonc2(int x) {
return (x * x);
}
Langage C : Prof. PAPA DIOP 118
MANIPULATION DES FICHIERS

Règles de visibilité des variables

Les variables ne peuvent être utilisées que là où elles sont déclarées
double func(int x); #include <stdio.h>
int glob=0; // variable globale
int next(){
void main(void)
{ static value = 0;
int i = 5, j, k = 2; //lacales à main return value++;
glob++;
func (i); }
func (k);
} void main(void) {
double func(int v) printf("Appel 1 : %d\n",next());
{
double d, f =v; //lacales à func printf("Appel 2 : %d\n",next());

glob++; }
f += glob; Appel 1 : 0
return f;
} Appel 2 : 1
Langage C : Prof. PAPA DIOP 119
Variables et fonctions externes
Le fichier impose lui aussi un domaine de visibilité. Une variable définie globale au fichier
(en dehors de toute fonction) ne sera alors visible que par les fonctions de ce fichier. Le
problème est de savoir comment exporter cette variable pour d’autres fonctions du
programme (externes au module) si le besoin s’en fait ressentir ?

Fichier "Module.h" Fichier "Module.c"

#include "module.h"
extern int a;
int a = 0;
void fct();
void fct() { a++; }

Fichier "main.c"
#include <stdio.h>
#include "module.h"

void main(void) {
fct();
a++;
printf("%d\n",a); // Résultat affiché : 2
}

Langage C : Prof. PAPA DIOP 120

 Directives de compilation

Les directives de compilation permettent d'inclure ou d'exclure du programme des

portions de texte selon l'évaluation de la condition de compilation.

#if defined (symbole) /* inclusion si symbole est défini */

#ifdef (symbole) /* idem que #if defined */
#ifndef (symbole) /* inclusion si symbole non défini */

#if (condition) /* inclusion si condition vérifiée */

#else /* sinon */
#elif /* else if */
#endif /* fin de si */
#undef symbole /* supprime une définition */

Langage C : Prof. PAPA DIOP 121

Exemple :

#ifndef (BOOL)
#define BOOL char /* type boolean */
#endif

#ifdef (BOOL)
BOOL FALSE = 0; /* type boolean */
BOOL TRUE = 1; /* définis comme des variables */
#else
#define FALSE 0 /* définis comme des macros */
#define TRUE 1
#endif Utile pour les fichiers include.

#ifndef _STDIO_H_
#define _STDIO_H_
texte a compiler une fois
…
#endif

Langage C : Prof. PAPA DIOP 122

 Listes chaînées
Une liste est une structure de données constituée de cellules
chaînées les unes aux autres par pointeurs.
Une liste simplement chaînée : une cellule est un
enregistrement qui peut être déclarée comme suit:
struct Node {
int data; /* les informations */
struct Node *next; /* le lien */
};

Une liste doublement chaînée

struct Node {
int data; /* les informations */
struct Node *next; /* lien vers le suivant */
struct Node *prev; /* lien vers le précédent */
};
Langage C : Prof. PAPA DIOP 123
 Structures de données dynamiques
typedef : mot réservé, typedef struct Node {
int data;
crée de nouveaux noms struct Node *next;
de types de données }cellule;
Ex :
typedef char * STRING; cellule * new_node(int value)
fait de STRING un synonyme {
de "char * « cellule * p;
Portée : comme les variables.

p=new struct Node; p = (cellule *)malloc(sizeof(cellule));

p->data = value;
p->next = NULL;

return p;
}
Langage C : Prof. PAPA DIOP 124
 Nouvelle cellule dans une liste chaînée vide
cellule *debut; Denis\0
debut = (cellule *) malloc (sizeof(cellule)); NULL
strcpy ( debut->name, “Denis”); debut
debut->next = NULL;
Le début de la liste est indiqué par un pointeur indépendant (debut) et la fin par NULL

Nouvelle cellule en début de liste chaînée

cellule *prec;
prec = (cellule *) malloc (sizeof(cellule));
strcpy ( prec->name, “Claire”);
prec->next = debut; Denis
Claire
debut = prec;
NULL

debut
Langage C : Prof. PAPA DIOP
prec 125
 Nouvelle cellule après la
cellule prec
cellule *p;
p = (cellule *) malloc (sizeof(cellule));
strcpy ( p->name, “Alfred”);
p->next = prec->next;
prec->next = p;
Alfred
OK?
p Denis
Claire
Claire Denis

debut NULL
NULL

prec
debut

Langage C : Prof. PAPA DIOP 126

 Parcourir une liste
void parcours (struct Node *debut) debut est un pointeur sur
{ la cellule qui contient le
struct Node *p; premier élément de la
p = debut;
while ( p != NULL) { liste
printf (“%s\n”, p->name);
Liste identifier par l'adresse
p = p->next; de sa première cellule
}
}
Alfred Denis
Claire
NULL

debut
Langage C : Prof. PAPA DIOP 127
 void liberation(liste L){
if (L) {
liste temp = L-
>suivant;
free(L);
liberation(temp);
}
}

void liberation (liste *lis)

{
liste *p;
while ( lis != NULL) {
p = lis;
lis=lis->next;
free(p);
}
}

Langage C : Prof. PAPA DIOP 128

 Exemple
LIFO
Last-In-First-Out
• Le dernier élément ajouté dans la
liste, est le premier à en sortir.

• Opérations:
Créer la pile,
Ajouter un élément (Push),
Effacer un élément (Pop),
Eliminer la pile .
Langage C : Prof. PAPA DIOP 129
 PUSH procédure

Push(5) 7 3 9 5
Push(9)
NULL
Push(3)
Top Top Top Top
Push(7)

Overflow risk si la pile est pleine!!!

Langage C : Prof. PAPA DIOP 130

 POP procédure

Pop(7) 7 3 9 5
Pop(3)
Underflow risk NULL
Pop(9) si la pile est vide !!!
Top Top
Top Top
Top Top
Top
Pop(5)

Langage C : Prof. PAPA DIOP 131

 Simulation de la factorielle
5! = ??
5! = 5*4!
4! = 4*3!
3! = 3*2!
2! = 2*1!
1! = 1*0! 0
0! = 1 1
2
3
4
5
Langage C : Prof. PAPA DIOP 132
 Simulation de la factorielle
5! = ??
5! = 5*4! 0! = 1
4! = 4*3! 1! = 1 *1 = 1
3! = 3*2! 2! = 2 *1 = 2
2! = 2*1! 3! = 3 *2 = 6
1! = 1*0! 4! = 4 *6 = 24 0
0! = 1 5! = 5 *24 = 120 1
2
3
4
5
Langage C : Prof. PAPA DIOP 133
 TP3
Créer une liste simplement chaînée dont chaque cellule contient les champs
suivants :

{
int data; /* les informations */
struct Node *next; /* le lien : pointeur sur la cellule suivante */
}

Le programme doit gérer en boucle le menu de choix suivant :

1- Créer une liste avec insertion en tête de liste (avec affichage)

2- Sauver la liste
3- Insérer dans la liste (avec affichage)
4- Nettoyer la mémoire et sortir

Langage C : Prof. PAPA DIOP 134

1 : Crée une liste en insérant 2n, puis 2n-2, puis 2n-4, … et enfin 0 qui sera
en tête de la liste. (Liste : 0,2,4,6,8,10, …2n.)

Push(6) 0 2 4 6
Push(4)
NULL
Push(2)
debut Top Top Top
Push(0)
2 : Sauvegarde la liste dans le fichier Liste1
3 : Insère dans la liste –1, puis 1, puis 3, … et en fin 2n-1.
(Liste finale : -1,0,1,2,3,4,5,6,7,8,9,…2n)
2’ : Sauvegarde la nouvelle liste dans le fichier Liste2
4 : Libère la mémoire avant de quitter le programme.
Langage C : Prof. PAPA DIOP 135
 Listes doublement chaînées
struct Node {
int data; /* les informations */
struct Node *prev; /* lien vers le précédent */ data prev next
struct Node *next; /* lien vers le suivant */
};

typedef struct Node Cell;

Cell *debut, *fin, *act;

debut
int dim = sizeof(Cell);

debut = (Cell *) malloc(dim);

fin = (Cell *) malloc(dim);
fin

Langage C : Prof. PAPA DIOP 136

 debut->prev = NULL;
data prev next
debut->next = fin;
fin->prev = debut;
fin->next = NULL;

NULL NULL

debut fin

Langage C : Prof. PAPA DIOP 137

 Insérer un élément en fin de liste
fin->next = act;
data prev next
act->prev = fin;
act->next = NULL;
fin = act;

NULL NULL

debut fin

NULL NULL

act fin
debut
Langage C : Prof. PAPA DIOP 138
 Insérer un élément dans la liste pos=qlq
Cell *tmp;
data prev next
tmp = (Cell *) malloc(dim);
tmp->prev = act->prev ;
act->prev->next = tmp;
tmp->next = act;
act->prev = tmp;

tmp

NULL NULL

act
debut fin

Langage C : Prof. PAPA DIOP 139

 tmp

NULL NULL

debut fin

NULL NULL

fin
debut

Langage C : Prof. PAPA DIOP 140

 typedef struct noeud {
Arbre binaire int donnee;
struct noeud *gauche;
struct noeud *droite;
}

Tri par arbre binaire de recherche ABR

Langage C : Prof. PAPA DIOP 141