Chapitre 1 Langage C 8 Mars

Université Abdelmalek Essaâdi
Faculté des Sciences et Techniques d’Al-Hoceima
Département de Mathématiques et
Informatique
Filière : MIP – S4
Année universitaire : 2021- 2022
Module M22 : Structures de données en C
Chapitre 1 : Langage C
Pr. Abderrahim zannou

a.zannou@uae.ac.ma
Pr . A. Zannou 1 FST d’ Al-Hoceima

Langage C
• Introduction
 Un langage de programmation est un intermédiaire entre l’homme et la

machine
 C a été initialement développé par Dennis Ritchie entre 1969 et 1973.
 C est un langage de programmation procédurale.
 Le langage C fait partie de la famille des langages de programmation
fonctionnels de haut niveau (comme Pascal, Ada, Fortran, etc...)
C a été principalement développé en tant que langage de
programmation système pour écrire un système d'exploitation (UNIX).
 Le C est un langage portable
 Le langage C reste un des langages les plus utilisés actuellement.
2
Pr . A. Zannou FST d’ Al-Hoceima
Langage C
• Structure d’un programme C
 Un programme source en langage C est une collection de variables,

constantes, et de fonctions pouvant être définies dans plusieurs fichiers
séparés.
 Une fonction nommée main doit exister de manière unique dans cet
ensemble.
 Elle (fonction main) correspond au programme principal exécuté par la
machine et faisant appel aux autres fonctions.
3
Langage C
• La compilation
 Compilation d’un programme est un ensemble de traitements successifs

sur un fichier source.
 Le but de la compilation est de générer un fichier exécutable par la
machine.
4
Langage C
• Les phases de compilation
 La première étape consiste à écrire le programme (on parle de code source) dans
un fichier texte à l’aide d’un éditeur.
 La deuxième étape est l’étape de pré-compilation. Elle consiste a traiter les
directives de compilation (comme l’inclusion de fichiers d’entête de bibliothèques).
Elle génère un fichier texte qui est encore un fichier source en C.
 L’étape suivante est la compilation. Elle consiste a transformer les instructions du
programme en langage compréhensible par le processeur (langage machine). Elle
génère un fichier binaire dit fichier objet (extension .o).
 La dernière étape consiste à effectuer l’édition de liens (par l’éditeur de liens).
Le code génère à la compilation est complété par le code des fonctions des
bibliothèques utilisées. C’est seulement après cette étape que l’on génère un fichier
exécutable.
5
Les variables
• Définition
 Elles servent à stocker les valeurs des données utilisées pendant

l’exécution d’un programme et elles doivent être déclarées avant d’être
utilisées.
 Une variable est caractérisée par un :
 nom (Identificateur) : constitué de lettres, de chiffres et du caractère
 type (entier, réel, …) : l’ensemble des valeurs qu’elle peut prendre.
6
Les variables
• types
 En langage C les principaux types de variables sont les suivants :

 Types booléen
 bool : booléen codé sur 1 octet.
 Types caractère
 char : caractères sur 1 octet.
 Types entier : 5 variantes d’entiers
 short ou short int : entier cour sur 2 octets.
 int : entier standard sur 2 ou 4 octets.
 long ou long int : entier long sur 4 octets.
 Types réel: 3 variantes de réels
 float: réel simple précision codé sur 4 octets.
 double : réel double précision codé sur 8 octets
 long double: réel très grand codé sur 16 octets
7
Les variable
• Déclaration
 La déclaration introduit les variables qui seront utilisées, leur type

et parfois aussi leur valeur de départ (initialisation).
 Syntaxe:
TypeVar nomVar1, nomVar2, .. , nomVar3;
 Exemple:
int i, j;
float a=1.2;
double c;
short d;
char e=‘A’;
8
Les constantes
• Définition et déclaration
 Une constante est une zone mémoire qui conserve sa valeur pendant
toute l’exécution d’un programme.
 On associe une valeur à une constante en utilisant :
 la directive #define :
#define nom_constante valeur;
Exemple:
#define pi 3.14;
#define nom "ahmed";
 La constante ne possède pas de type
 le mot clé const :
const type nom_constante = valeur;
Exemple:
const float Pi =3.14;
const int taille= 200;
 la constante est typée
9
Expression et opérations
• Définition
 Une expression peut être une valeur, une variable ou une opération.
Par exemple:
2; a, 2*a, 2*a+c
 Une expression fournit une seule valeur, elle est évaluée en respectant
des règles de priorité et d’associativité.
 Un opérateur est un symbole qui permet de manipuler des variables
(opérandes) pour produire un résultat.
10
Expression et opérations
• Opérateurs du langage C
 opérateurs arithmétiques : +, -, *, /, % (modulo)

 opérateurs d’affectation : =, +=, -=,*=,/=,…
 opérateurs logiques : &&, ||, !
 opérateurs de comparaison : ==, !=, <, >, <=, >=
 opérateurs d’incrémentation et de décrémentation : ++, --
 opérateurs sur les bits : &, |, ~, ^, <<, >>
 autres opérateurs particuliers : ?:, sizeof, cast, …
11
Les variable
• Opérateurs arithmétiques
 Les opérandes peuvent être des entiers ou des réels sauf pour % qui
agit uniquement sur des entiers.
 Lorsque les types des deux opérandes sont différents il y’a conversion
implicite dans le type le plus fort.
 La conversion implicite se fait comme suit :
int → long → float → double → long double.
12
Les variable
• Opérateur de forçage de type (cast)
 Il est possible d’effectuer des conversions explicites (casting) ou

de forcer le type d’une expression.
 Syntaxe :
(type) expression;
 Exemple
int n, p;
(double) (n )/ p);
convertit l’entier n/p en double
13
Les variable
• Opérateur conditionnel ?
 Syntaxe :
exp1 ? exp2 : exp3
exp1 est évaluée, si sa valeur est vérifiée, c’est exp2 qui est
exécutée, sinon exp3 qui est exécutée.
 Exemple 1 :
max = (a > b) ? a : b;
Si a>b alors on affecte à max le contenu de a, sinon on lui
affecte b.
 Exemple 2 :
int i=10;
(a > b) ? i++ : i--;
Si (a>b) on incrémente i sinon on décrémente i
14
Les variable
• Sizeof
 Sizeof fournit la taille en octets d'un type ou d'une variable.

 Syntaxe :
sizeof (type); ou sizeof (variable);
 Exemples :
double n;
printf ("%d \n",sizeof(int)); //affiche 4
printf ("%d \n",sizeof(n)); //affiche 8
15
Entrées/sorties
• Printf()
 Syntaxe :
printf("format", expr1, expr2, …);
 expr1, expr2, …: variables et expressions dont on veut afficher la valeur.
 Format : chaîne de caractères qui peut contenir :
• du texte.
• des séquences d’échappement (\n).
• des spécificateurs de format : indiquant le format d’affichage
16
Entrées/sorties
• Les spécificateurs de format
 Les spécificateurs de format:
Symbole Type Affichage comme

%d ou %i int Entier relatif
%u Unsigned int Entier naturel non signé
%c char Caractère
%f Float, double Réel en notation décimale
%s char Chaine de caractères
17
Entrées/sorties
• Scanf()
 Syntaxe :
scanf("format", AdrVar1, AdrVar2, …);
 Format : format de lecture de données (le même que pour printf).
 adrVar1, adrVar2, … : adresses des variables auxquelles les données
seront attribuées. Ces adresses sont indiquées par le nom des variables
précédé du signe &
18
Structures de contrôle
• Introduction
 Les structures de contrôle conditionnent l'exécution des instructions en

fonction de la valeur d'une expression.
 On distingue deux types de structures de contrôle :
 Structures alternatives (tests) : permettent d’effectuer des
choix : if … else et switch.
 Structures répétitives (boucles) : permettent de répéter
plusieurs fois l’exécution d’un ensemble d’instructions :
for , do…while, et while.
19
• if .. else
Syntaxe (1):
#include <stdio.h>
 if (condition)
int main()
instruction;
{
else
float age;
instruction;
scanf("%f\n", &age);
if (age>=18)
printf("Accepté \n");
else
printf("refusé \n");
}
20
• if .. else
Syntaxe (2): #include <stdio.h>

 if (condition) int main()
instruction; {
else if (condition) float age;
instruction; scanf("%f\n",&age);
….. if (age>=18 && age<40 )
else printf("Accepté \n");
instruction; else if (age>40)
printf("agé \n");
else
printf("refusé \n");
}
21
• if .. else
 else est toujours associé au dernier if qui ne possède pas une partie else.
 Pour éviter toute ambiguïté ou pour forcer une certaine interprétation, il
vaut mieux utiliser les accolades : {….}
22
• Switch .. case
 Pour éviter les imbrications d’instructions if, le C possède une instruction

qui permet d’explorer plusieurs cas en même temps : c’est l’instruction
switch. #include <stdio.h>
int main()
 Syntaxe :
{
switch(variable) int jour;
{ printf("saisir le numéro du jour : ");
case valeur1 : scanf("%d",&jour);
instruction; switch(jour)
break; {
case 1 : printf("Lundi");break;
case valeur2 :
case 2 : printf("Mardi");break;
instruction; case 3 : printf("Mercredi");break;
break; case 4 : printf("Jeudi");break;
default : case 5 : printf("Vendredi");break;
instruction ; case 6 : printf("Samedi");break;
break; case 7 : printf("Dimanche");break;
} default: printf("invalide");break;
}
}
23
• while
 Instruction while:
 L’instruction s’exécute tant que le résultat du test est vrai.
 L’instruction n’est pas exécutée si le résultat du test est faux la
première fois. Exemple: afficher les nombres entre 1 et 10
 Syntaxe:
#include <stdio.h>
while(condition) int main()
{
{
int i=1;
Instruction(s) while(i<=10)
{
}
printf(”%d\n”,i);
i=i+1;
}
}
24
• do .. while
 Instruction do .. while :
 L’instruction est exécutée une fois, puis répétée si le résultat du
test est vrai.
 L’instruction est exécutée au moins une fois.
 Syntaxe: Exemple: Entrer un entier qui doit être positif,
do
sinon on repose la question.
{
printf(”Entrez un nombre #include <stdio.h>
positif.\n”);
int main()
scanf(”%d”,&a);
{
} int a;
while (condition); do
{
printf(”Entrez un nombre positif.\n”);
scanf(”%d”,&a);
}
while (a<0);
}
25
• for
 Une boucle for permet de répéter une instruction plusieurs

fois, à l’aide d’une variable de contrôle. Exemple: somme des entiers de 1 à 10
 Syntaxe #include <stdio.h>
int main()
for(init;test;itération) {
int i,s=0;
{
for (i=1;i<=10;i++)
instruction(s) {
s=s+i;
} }
printf("Somme=%d\n",s);
 Tels que:
}
 init: initialiser la variable de contrôle.
 test: test de la variable de contrôle
 itération: opération sur la variable de contrôle
26
• Les instructions break et continue : break
 L’instruction break peut être utilisée dans une boucle (for, while,
ou do .. while) pour arrêter le déroulement de la boucle et passer
à la première instruction qui la suit .
 En cas d’imbrication de boucles, break ne quitte que la boucle
(ou le switch) le plus interne.
27
• Les instructions break et continue : continue
 L’instruction Continue peut être utilisée dans une boucle (for, while, ou do ..
while) pour abandonner l’itération courante et passer à l’itération suivante.
#include <stdio.h>
int main()
{
int i;
for (i=1;i<5;i++)
{
printf("début itération%d\n",i);
if (i<3)
continue;
printf("Fin itération%d\n",i);
}
}
28
Les tableaux
• Caractéristiques
 Un tableau est une variable structurée composée d’un nombre de

variables simples de même type appelées éléments.
 Les éléments du tableau sont stockées en mémoire à des emplacements contigûs
(l’un après l’autre).
 Le type des éléments du tableau peut être :
un type simple : char, int, float, double, …
un pointeur.
une structure.
 Un tableau peut être unidimensionnels ou multidimensionnel
29
Les tableaux
• Tableaux unidimensionnels
 Syntaxe de déclaration : Type nom[dimension];

 Exemple : float notes[30];
 Initialisation à la déclaration : Type nom[dimension] = {val1, val2, val3, …};
 Exemple : int A[5] = {1, 2, 3, 4, 5};
 Accès aux éléments d’un tableau :
 L'accès à un élément du tableau se fait au moyen de l'indice T[i].
int main()
{
float tA[2];
int tB[3]={2,4,7};
tA[0]= 5;
tA[1]= 8;
printf("%f\n",tA[0]); //afichage 5.00000
printf("%i\n",tB[2]); //afichage 7
}
30
Les tableaux
• Tableaux multidimensionnels
 Un tableau multidimensionnel est un tableau qui contient des tableaux.

 Syntaxe : Type Nom[d1][d2]…[dn];
 Exemple : Tableaux à deux dimensions :
short T[2][3];
➢ T est un tableau comportant 2 éléments, chacun d'entre eux étant
un tableau de 3 éléments.
➢ On peut représenter le tableau A de la manière suivante :
T[0][0] T[0][1] T[0][2]

T[1][0] T[1][1] T[1][2]
31
Les tableaux
• Tableaux multidimensionnels
 Initialisation à la déclaration
float A[3][4] = { {-1.5, 2.1, 3.4, 0},{8, 7.5,1, 2.7 }, {3.1, 0, 2, -1} } ;
32
Les fonctions
• Syntaxe de définition
 Une fonction est définie en dehors de la fonction principale main () par la

syntaxe suivante :
type nom_fonction (type1 arg1,…, typeN argN) { // en-tête
instructions; //corps de la fonction
return (expression);
}
 L’en-tête (prototype) de la fonction contient :
 type : c’est le type du résultat retourné. Si la fonction n’a pas de résultat à
retourner, elle est de type void.
 nom de la fonction : Identificateur de la fonction
 parenthèses : on spécifie les arguments de la fonction et leurs types. S’il n
y a pas de paramètres, on peut déclarer les paramètres comme ().
 Pour fournir un résultat en quittant une fonction, on utilise la commande
return
33
Les fonctions
• Appel d’une fonction
 L‘appel d'une fonction se fait par simple écriture de son nom avec la liste
des paramètres :
nom_fonction (para1, para2, …, paraN);
 Lors de la définition d'une fonction, les paramètres sont appelés paramètres
formels.
 Lors de l'appel, les paramètres sont appelés paramètres effectifs.
 L'ordre et les types des paramètres effectifs doivent correspondre à ceux des
paramètres formels.
34
Les fonctions
• Syntaxe de déclaration
 Il est interdit en C de définir des fonctions à l'intérieur d'autres fonctions.

 La déclaration des fonctions est obligatoire si ces fonctions sont définies après
la fonction principale main().
35
Les fonctions
• Syntaxe de déclaration
 Exemple : Déclaration et appel d’une fonction :
#include <stdio.h>
float carre(float);//declaration de la fonction
int main()
{
float c;
scanf(" Entrer un nombre %f\n",&c);
printf("Le carré de %f est %f \n", c, carre(c));//appel de la fonction
return 0;
}
float carre( float x)//définition de la fonction
{
return x*x;
}
36
Les fonctions
• Variables locales et globales
 Exemple
#include <stdio.h>
float puissance( float x);
float x=1; // variable globale
int main()
{
float c; // variable locale
return 0;
}
float puissance( float x) {
int i; //variable locale
}
37
Les fonctions
 Les variables déclarées au début de la fonction principale main() ne sont pas

des variables globales, mais elles sont locales à main().
 En général, les variables globales sont déclarées immédiatement derrière les
instructions #include au début du programme.
 Une variable déclarée dans un bloc d'instructions {…} est locale à ce bloc.
38
Les fonctions
 On peut manipuler 2 types de variables qui se distinguent par leur portée:

variable locale :
 définie à l'intérieur d’une fonction
 n’est connue qu’à l’intérieur de cette fonction.
 Elle est créée à l'appel de la fonction et détruite à la fin
de son exécution.
variable globale :
 définie à l’extérieur des fonctions et est définie durant toute l’application;
 Elle peut être utilisée et modifiée n’importe où dans le programme.
39
Les fonctions
• header
 Exemple :
surface.h main.c
float carre( float a) #include <stdio.h>

{ #include "surface.h";
return a*a; int main() {
} printf("La surface du carre est : %f \n", carre(3));
float cercle( float r) printf("La surface du cercle est : %f ", cercle(4));
{ }
return 3.14*r*r;
}
40
Les fonctions
• Récursivité
 Une fonction récursive est une fonction qui fait appel à elle-même.
 Toute fonction récursive doit posséder un cas limite (cas trivial) qui arrête
la récursivité.
 Exemple : Un fonction qui calcule le factorielle d’un entier :
#include <stdio.h>
int factorielle(int);//declaration de la fonction
int main()
{
int n;
scanf(" %f",&n);
printf("La factorielle de %i est %i \n", n, factorielle(n));//appel de la fonction
}
int factorielle( int n)//définition de la fonction
{
if (n=0)
return 1;
else
return n*factorielle(n-1);
}
41
Les pointeurs
• Définition
 Un pointeur est une variable spéciale qui peut contenir l’adresse

d’une autre variable.
Exemple :
 A est une variable qui contient la valeur 10.
 P est un pointeur qui contient l'adresse de A (P pointe sur A).
P 2E01 3D14
A 10 2E01
Mémoire
42
Les pointeurs
• Définition
 Le nom d’une variable permet d'accéder directement à sa valeur :

adressage direct.
 Un pointeur qui contient l'adresse de la variable, permet d'accéder
indirectement à la valeur de cette variable : adressage indirect.
 Le nom d'une variable est lié à la même adresse, alors qu’un
pointeur peut pointer sur différentes adresses.
43
Les pointeurs
• Déclaration
 Syntaxe : type *nom-du-pointeur ;

 type : c’est le type de la variable pointée.
 * : c’est l’opérateur qui indique au compilateur que c’est un pointeur.
 Exemples :
int *pi; //pi est un pointeur vers une variable de type int.
float *pf; //pf est un pointeur vers une variable de type float.
 Remarque :
La valeur d’un pointeur donne l’adresse du premier octet parmi les n
octets où la variable est stockée.
44
Les pointeurs
• Opérateurs de manipulation
 Lors du travail avec des pointeurs, nous utilisons :

 L’opérateur & : 'adresse de' : pour obtenir l'adresse d'une variable.
 L’opérateur * : 'contenu de' : pour accéder au contenu d'une adresse
(un pointeur).
 Exemples :
int * p; //on déclare un pointeur vers une variable de type int
int i=10, j=30; // deux variables de type int
p=&i; // on met dans p, l’adresse de i (p pointe sur i)
printf("%d \n",*p); //affiche : 10
*p=20; // met 20 dans la case pointée par p (i vaut 20 après l’instruction)
p=&j; // p pointe sur j
i=*p; // affecte le contenu de p à i (i vaut 30 après cette instruction)
45
Les pointeurs
• Passage par valeur
 Lors de l'appel d'une fonction, on lui donne des valeurs sous forme de
paramètres. Il existe donc le type de passages qu'on appelle par valeur,
qui consiste à passer une copie de notre valeur à la fonction. Ainsi la
fonction ne manipulera que cette copie de notre valeur, et tous les
changements qui y seront apportés, ne seront pas pris en compte
ailleurs.
46
Les pointeurs
• Passage par valeur
 Exemple :
Passage par valeur
void ma_fonction(int n)
{
n = 10;
}
void main ()
{
int var = 123;
ma_fonction(var);
printf("La valeur de variable est %d\n",var);
}
Affichage:
La valeur de variable est 123
47
Les pointeurs
• Passage par adresse
 Ce type de passage donnera un résultat différent de celui présenté

précédemment. Il consiste à envoyer l'adresse mémoire de notre variable et
non pas sa valeur. Ainsi on a accès à l'emplacement même de cette variable en
mémoire. Donc les changements qu'on apportera à cet espace mémoire,
seront des changements qu'on aura apportés à notre variable directement.
48
Les pointeurs
• Passage par adresse
 Exemple :
Passage par adresse
void ma_fonction(int * n)
{
*n = 10;
}
void main ()
{
int var = 123;
ma_fonction(&var);
printf("La valeur de variable est %d\n",var);
}
Affichage:
La valeur de variable est 10
49
Les pointeurs
• Passage par adresse et par valeur
 Exemple
Passage par valeur Passage par adresse/référence
void echange(int x, int y) void echange(int* x, int*y)
{ {
int temp; int temp;
temp=x; temp=*x;
x=y; *x=*y;
y=temp; *y=temp;
} }
void main() void main()
{ {
int a=2, b=3; int a=2, b=3;
echange(a,b); echange(&a,&b);
printf("a = %d et b=%d",a,b); printf("a = %d et b=%d",a,b);
} }
Affichage: Affichage:
a= 2 et b=3 a= 3 et b=2
50
Les pointeurs
• Initialisation
 A la déclaration d’un pointeur p (int *p; ), on ne sait pas sur quel zone
mémoire il pointe. Ceci peut générer des problèmes.
Conseil :
 Toute utilisation d’un pointeur doit être précédée par une initialisation.
 On peut initialiser un pointeur en lui affectant :
 l’adresse d’une variable :
Exemple : int a, *p1; p1=&a;
 Un autre pointeur déjà initialisé :
Exemple : int *p2; p2=p1;
51
Les pointeurs
• Pointeurs et tableaux
 Le nom d'un tableau représente l'adresse de son premier élément.

 Si on déclare un tableau T, alors : T=&T[0].
 On peut dire que T est un pointeur sur le 1er élément du tableau.
 En déclarant un tableau T et un pointeur P du même type, l’instruction P=T
fait pointer P sur le premier élément de T : P=&T[0].
P .
3 20 6
T[0] T[1] T[2]
52
Les pointeurs
• Pointeurs et tableaux
 A partir de là, on peut manipuler le tableau T en utilisant P, en effet :

 P pointe sur T[0] et *P désigne T[0]
 P+1 pointe sur T[1] et *(P+1) désigne T[1]
 ….
 P+i pointe sur T[i] et *(P+i) désigne T[i]
P .
3 20 6
T[0] T[1] T[2]
53
Les chaines de caractères
 En langage C, il n'existe pas de type spécial pour les chaines de caractères.

Une chaîne de caractères est traitée en C comme un tableau de caractères.
M I P \0
 Le dernier élément d’une chaîne de caractères vaut le caractère ‘\0’.

 Syntaxe :
char NomVariable [Longueur];
 Exemple :
char var[2]="abcd";
printf("%s",var);
54
 Pour une chaîne de N caractères, on a besoin de N+1 octets en mémoire (le

dernier octet est réservé pour le caractère ‘\0’).
 Le nom d’une chaîne de caractères est le représentant de l’adresse du 1er
caractère de la chaîne (on peut manipuler les chaînes de caractères en
utilisant des pointeurs).
 Il existe plusieurs fonctions prédéfinies pour le traitement des chaînes de
caractères.
55
• Initialisation
 On peut initialiser une chaîne de caractères à la définition par l’une des trois
méthodes suivantes :
 Comme un tableau.
char ch[] = {‘e’, ’c’, ’o’, ’l’, ’e’, ’\0’};
 Par une chaîne constante.
char ch[] = "ecole";
 Par un pointeur : en attribuant l'adresse d'une chaîne de caractères
constante à un pointeur de type char.
char *ch = "ecole";
56
• Manipulation
 Le langage C dispose de plusieurs bibliothèques contenant des fonctions

pour le traitement de chaînes de caractères.
57
• Manipulation
 Bibliothèque <string.h> :
Fonction Rôle Exemple

fournit la longueur de la char ch[ ]= “ Test ";
strlen(ch)
chaîne ch sans compter le '\0' printf(“%d”,strlen(ch)); //affiche 4
char ch1[20]=" Bonne", ch[]="chance
ajoute ch2 à la fin de ch1. Le
";
strcat(ch1, ch2) ‘\0’ de ch1 est écrasé par le 1er
strcat(ch1, ch2) ;
caractère de ch2
printf(" %s", ch1); //Bonnechance
retourne une valeur : nulle si ch1 et
compare ch1 et ch2 du point
strcmp(ch1, ch2) ch2 sont identiques, négative si ch1
de vue lexicographique.
précède ch2, positive si ch1 suit ch2.
char ch[10];
copie ch2 dans ch1 y compris
strcpy(ch1, ch2) strcpy(ch, " Bonjour ");
le caractère ‘\0
printf(“%s”,ch); // Bonjour
58
• Manipulation
 Les principales bibliothèques et fonctions sont :

Bibliothèque <stdio.h> :
Fonction Rôle Exemple
printf() permet d’afficher une chaîne en
char ch[ ]= "Bonsoir " ;
utilisant le spécificateur de format printf(" %s ", ch)
%s.
puts(ch) affiche la chaîne désignée par ch et char ch[ ]= " Bonsoir " ;
provoque un retour à la ligne. puts(ch);
scanf() permet de saisir une chaîne de char Nom[15];
caractères en utilisant le printf("entrez votre nom");
spécificateur de format %s scanf(" %s ", &Nom);
gets(ch) lit la chaîne de caractères désignée
char phrase[100];
printf("entrez une phrase");
par ch. gets(phrase);
59
Allocation dynamique de la mémoire
• Introduction
 Dans un programme, si on ne connaît pas la taille des données au moment

de la programmation, on réserve l'espace maximal prévisible.
 Exemple :
 On considère un tableau de int : int tableau[100];
 Le tableau occupera alors en réalité 4 * 100 = 400 octets en mémoire.
 Même si le tableau est vide, il prend 400 octets !! La place en mémoire est
réservée, aucun autre programme n'a le droit d'y toucher.
Gaspillage de la mémoire
60
Types d’allocation de mémoire
• Introduction
 Allocation automatique: lorsque on déclare une variable à l’aide d’un type

de données de base, le compilateur alloue automatiquement de l’espace
mémoire pour la variable dans une zone de mémoire RAM appelée Stack
(la pile).
 Allocation dynamique: Le compilateur alloue ou libère manuellement de
l’espace mémoire en fonction des besoins de programmation. La mémoire
est gérée dans une partie de la mémoire RAM appelée Heap (le tas).
61
• Introduction
 Pour éviter le gaspillage de la mémoire, il faut allouer la mémoire en

fonction des données à saisir (par exemple la dimension d’un tableau): c’est
l’allocation dynamique de la mémoire.
 En langage C, la bibliothèque <stdlib.h> contient quatre fonctions pour
allouer ou libérer de la mémoire :
 malloc(), calloc, realloc : (memory allocation) : demande au système
d'exploitation la permission d'utiliser de la mémoire.
 free() : (Libérer) : permet d'indiquer à l'OS que l'on n'a plus besoin de
la mémoire qu'on avait demandée (un autre programme peut s'en
servir).
62
• Fonction malloc()
 Syntaxe :
malloc(N); //N:nombre d’octets
 La fonction malloc retourne :
 Un pointeur de type char * pointant vers le premier octet.
 Le pointeur NULL s’il n’y a pas assez de mémoire libre à allouer.
 Exemple : Réserver la mémoire pour un texte de 100 caractères :
char *T;
T = malloc(100);
➢ Cette instruction fournit l'adresse d'un bloc de 100 octets et l'affecte à T.
➢ S'il n'y a pas assez de mémoire, T obtient la valeur NULL.
63
• Fonction free()
 Une fois qu'on a fini d'utiliser la mémoire, on doit la libérer à l'aide de la

fonction free.
 Syntaxe :
free(pointeur);
 Exemple : Libérer la mémoire réservé pour un texte de 100 caractères :
char *T;
T = malloc(100);
… //utilisation de la mémoire
free(T);
64
• Fonction free()
 Remarques :
 Si on appelle pas la fonction free, on s'expose à des fuites de mémoire (le
programme risque au final de prendre beaucoup de mémoire alors qu'il n'a en
réalité plus besoin de tout cet espace).
 Si on ne libère pas explicitement la mémoire à l'aide de free, alors elle est
libérée automatiquement à la fin du programme
65
• Malloc et free
 Exemple
void main()
{
/*Traitement de p1*/
int *p1=malloc(3*sizeof(int));
*(p1+0)=2;
*(p1+1)=5;
*(p1+2)=7;
printf("%p",p1); // 20CD23EF
free(p1);
/*Traitement de p2*/
int *p2=malloc(2*sizeof(int)); // 20CD23EF
*(p2+0)=2;
*(p2+1)=5;
printf("%p",p2);
}
66
• Calloc
 La fonction calloc alloue un bloc de mémoire en initialisant tous ces octets à la

valeur 0.
 La fonction malloc ne modifie pas la zone de mémoire.
 La syntaxe de calloc:
void* calloc (nb_elements, taille_element)
 La fonction calloc retourne :
67
• Calloc
 Exemple.
En utilisant malloc En utilisant calloc

{ {
int *p1=malloc(3*sizeof(int)); int *p2=malloc(3, sizeof(int));
*(p1+0)=2; *(p2+0)=2;
*(p1+1)=5; *(p2+1)=5;
*(p1+2)=7; *(p2+2)=7;
} }
68
• La foncion realloc
 La fonction realloc permet de réallouer un bloc de mémoire dans le tas (le heap
en anglais).
 Si l’espace mémoire libre suit le bloc à réallouer est suffisamment grand, alors
le bloc de mémoire est simplement agrandi.
 Si l’espace mémoire libre suit le bloc à réallouer est n’est pas suffisant, alors
le contenu de la zone d’origine recopié dans la nouvelle zone et le bloc mémoire
d’origine sera libéré automatiquement.
 La syntaxe de realloc:
void* realloc (pointeur, taille_octets)
 La fonction calloc retourne :
69
• Calloc
 Exemple.
En utilisant malloc En utilisant calloc

{ {
int *p1=malloc(3*sizeof(int)); int *p2=calloc(3, sizeof(int));
*(p1+0)=2; *(p2+0)=2;
*(p1+1)=5; *(p2+1)=5;
*(p1+2)=7; *(p2+2)=7;
} }
En utilisant realloc
void main()
{
int *p1=malloc(3*sizeof(int));
p1=realloc(p1, 5*sizeof(int))
*(p1+4)=10;
*(p1+5)=20;
}
70
La gestion des fichiers
• Introduction
 Le C offre la possibilité de lire et d'écrire des données dans un fichier.

 Les accès à un fichier se font par l'intermédiaire d'une mémoire-tampon
(buffer), ce qui permet de réduire le nombre d'accès aux périphériques
(disque dur, ...).
 Pour pouvoir manipuler un fichier, un programme a besoin d'un certain
nombre d'informations : l'adresse de l'endroit de la mémoire-tampon
où se trouve le fichier, la position de la tête de lecture, le mode
d'accès au fichier (lecture ou écriture)
 Ces informations sont rassemblées dans une structure dont le type, file *,
est défini dans stdio.h.
 Un objet de type file * est appelé flot de données (en anglais, stream).
71
• Ouverture et fermeture d'un fichier
 Avant de lire ou d'écrire dans un fichier, on notifie son accès par la

commande/fonction fopen().
 Cette fonction prend comme argument le nom du fichier, négocie avec le
système d'exploitation et initialise un flot de données, qui sera ensuite
utilisé lors de l'écriture ou de la lecture.
 Après les traitements, on annule la liaison entre le fichier et le flot de
données grâce à la fonction fclose().
72
 Exemple: Ouvrir un fichier
#include <stdio.h>
void main()
{
FILE * fp=fopen("fichier.txt","r");
if (fp==NULL)
printf("Erreur!\n");
else
printf(" Réusite!\n");
fclose(fp);
}
Affichage
Erreur!
73
• Fonction fopen()
 La fonction fopen est de type FILE* ouvre un fichier et lui associe un flot
de données.
 La valeur retournée par fopen est un flot de données.
 Si l'exécution de cette fonction (fopen) ne se déroule pas normalement,
la valeur retournée est le pointeur NULL.
 Il est donc recommandé de toujours tester si la valeur renvoyée par la
fonction fopen est égale à NULL afin de détecter les erreurs (lecture d'un
fichier inexistant...).
 La fonction fclose retourne un entier qui vaut zéro si l'opération s'est
déroulée normalement (et une valeur non nulle en cas d'erreur).
74
 Remarque: On préférera définir le nom du fichier par une constante

symbolique au moyen de la directive #define plutôt que d'expliciter le nom de
fichier dans le corps du programme.
#include <stdio.h>
#define pt "fichier.txt";
// #define pt "C:\\dossier1\\fichier.txt"
void main()
{
FILE * fp=fopen(pt,"r");
if (fp==NULL)
printf("Erreur!\n");
else
printf(" Réusite!\n");
fclose(fp)
}
75
• Mode d’accès aux fichiers
 Le second argument,(mode d’accès aux fichiers ), est une chaîne de

caractères qui spécifie le mode d'accès au fichier.
 Les différents modes d'accès sont les suivants :
"r" ouverture d'un fichier texte en lecture

"w" ouverture d'un fichier texte en écriture
"a" ouverture d'un fichier texte en écriture à la fin
76
• Mode d’accès aux fichiers
 Ces modes d'accès ont pour particularités :

 Si le mode contient la lettre r, le fichier doit exister.
 Si le mode contient la lettre w, le fichier peut ne pas exister. Dans ce cas,
il sera créé. Si le fichier existe déjà, son ancien contenu sera perdu.
 Si le mode contient la lettre a, le fichier peut ne pas exister. Dans ce cas,
il sera créé. Si le fichier existe déjà, les nouvelles données seront
ajoutées à la fin du fichier précédent.
77
• La fonction d’ écriture fprintf
 La fonction fprintf, analogue à printf, permet d’écrire des données dans

un fichier.
 Syntaxe:
fprintf(flot, "chaîne de Contrôle",expression-1, ..., expression-n)
 où flot est le flot de données retourné par la fonction fopen. Les
spécifications de format utilisées pour la fonction fprintf sont les mêmes
que pour printf.
78
• fonction d'écriture fscanf
 La fonction fscanf, analogue à scanf, permet de lire des données dans un
fichier.
 Syntaxe est semblable à celle de scanf :
fscanf(flot,"chaîne de contrôle",argument-1,...,argument-n)
 où flot est le flot de données retourné par fopen. Les spécifications de format
sont ici les mêmes que celles de la fonction scanf.
79
• La fonction d’ écriture fprintf
 Exemple: écrire dans un fichier
#include <stdio.h>
void main()
{
FILE * fp=fopen("fichier.txt","a");
char nom[20];
if (fp==NULL)
printf("Erreur!");
else
{
printf("Entrer votre nom: \n");
scanf("%s",nom);
fprintf(fp,"%s \n",nom);
}
fclose(fp);
}
80
• La fonction d’ écriture fputs
 Exemple: écrire dans un fichier en utilisant puts, gets, et fputs
#include <stdio.h>
void main()
{
FILE * fp=fopen("fichier.txt","a");
char nom[20];
if (fp==NULL)
printf("Erreur!");
else
{
puts("Entrer votre nom:");
gets(nom);
fputs(nom,fp);
}
fclose(fp);
}
81
• La fonction de saisie fscanf
 Exemple: Lire à partir de fichier

#include <stdio.h> Fichier.txt
void main() Salah
{
FILE * fp=fopen("fichier.txt","r"); Kamal
char buff[100]; Nadir
if (fp==NULL)
printf("Erreur!");
else Affichage
{ Salah
fscanf(fp,"%s",buff);
printf("%s",buff);
}
fclose(fp);
}
82
• La fonction de saisie fscanf - la fonction feof
 Exemple: Lire à partir de fichier en utilisant la fonction feof()

void main() Salah
{
if (fp==NULL)
printf("Erreur!");
else{ Affichage
while (!feof(fp)){ Salah
fscanf(fp,"%s",buff);
Kamal
printf("%s \n",buff);
} Nadir
}
fclose(fp);
}
83
• La fonction de saisie fgets
 Exemple: Lire à partir de fichier en utilisant fgets

void main() Salah
{
if (fp==NULL)
printf("Erreur!");
else{ Affichage
fgets(buff,3,fp); Sa
printf("%s",buff);
}
fclose(fp);
}
84
• La fonction de saisie fgetc
 Exemple: Lire à partir de fichier en utilisant fgetc

void main() Salah
{
char var; Nadir
if (fp==NULL)
printf("Erreur!");
else{ Affichage
var=fgetc(fp); S
printf("%c",var);
}
fclose(fp);
}
85

Chapitre 1 Langage C 8 Mars

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Chapitre 1 Langage C 8 Mars

Transféré par

Droits d'auteur :

Formats disponibles

Université Abdelmalek Essaâdi

Faculté des Sciences et Techniques d’Al-Hoceima

Module M22 : Structures de données en C

Pr. Abderrahim zannou

Pr . A. Zannou 1 FST d’ Al-Hoceima

 Un langage de programmation est un intermédiaire entre l’homme et la

 Un programme source en langage C est une collection de variables,

 Compilation d’un programme est un ensemble de traitements successifs

 Elles servent à stocker les valeurs des données utilisées pendant

 En langage C les principaux types de variables sont les suivants :

 La déclaration introduit les variables qui seront utilisées, leur type

 opérateurs arithmétiques : +, -, *, /, % (modulo)

 Il est possible d’effectuer des conversions explicites (casting) ou

 Sizeof fournit la taille en octets d'un type ou d'une variable.

 Les spécificateurs de format:

Symbole Type Affichage comme

 Les structures de contrôle conditionnent l'exécution des instructions en

Syntaxe (2): #include <stdio.h>

 Pour éviter les imbrications d’instructions if, le C possède une instruction

 Une boucle for permet de répéter une instruction plusieurs

 Un tableau est une variable structurée composée d’un nombre de

 Syntaxe de déclaration : Type nom[dimension];

 Un tableau multidimensionnel est un tableau qui contient des tableaux.

T[0][0] T[0][1] T[0][2]

 Une fonction est définie en dehors de la fonction principale main () par la

 Il est interdit en C de définir des fonctions à l'intérieur d'autres fonctions.

 Exemple : Déclaration et appel d’une fonction :

 Les variables déclarées au début de la fonction principale main() ne sont pas

 On peut manipuler 2 types de variables qui se distinguent par leur portée:

float carre( float a) #include <stdio.h>

 Un pointeur est une variable spéciale qui peut contenir l’adresse

 Le nom d’une variable permet d'accéder directement à sa valeur :

 Syntaxe : type *nom-du-pointeur ;

 Lors du travail avec des pointeurs, nous utilisons :

 Ce type de passage donnera un résultat différent de celui présenté

 Le nom d'un tableau représente l'adresse de son premier élément.

 A partir de là, on peut manipuler le tableau T en utilisant P, en effet :

 En langage C, il n'existe pas de type spécial pour les chaines de caractères.

 Le dernier élément d’une chaîne de caractères vaut le caractère ‘\0’.

 Pour une chaîne de N caractères, on a besoin de N+1 octets en mémoire (le

 Le langage C dispose de plusieurs bibliothèques contenant des fonctions

Fonction Rôle Exemple

 Les principales bibliothèques et fonctions sont :

 Dans un programme, si on ne connaît pas la taille des données au moment

 Allocation automatique: lorsque on déclare une variable à l’aide d’un type

 Pour éviter le gaspillage de la mémoire, il faut allouer la mémoire en

 Une fois qu'on a fini d'utiliser la mémoire, on doit la libérer à l'aide de la

 La fonction calloc alloue un bloc de mémoire en initialisant tous ces octets à la

void main() void main()

void main() void main()

 Le C offre la possibilité de lire et d'écrire des données dans un fichier.

 Avant de lire ou d'écrire dans un fichier, on notifie son accès par la

 Exemple: Ouvrir un fichier

 Remarque: On préférera définir le nom du fichier par une constante

 Le second argument,(mode d’accès aux fichiers ), est une chaîne de

"r" ouverture d'un fichier texte en lecture

 Ces modes d'accès ont pour particularités :

 La fonction fprintf, analogue à printf, permet d’écrire des données dans

 Exemple: écrire dans un fichier

 Exemple: écrire dans un fichier en utilisant puts, gets, et fputs

 Exemple: Lire à partir de fichier

 Exemple: Lire à partir de fichier en utilisant la fonction feof()

 Exemple: Lire à partir de fichier en utilisant fgets

 Exemple: Lire à partir de fichier en utilisant fgetc