Génie Électrique et Technologies

Emergentes

Informatique 2
- Electronique Embarquée et Systèmes Intelligents

- Electrotechnique Industrielle et Mobilité Electrique

Pr. Azeroual Mohamed

[Link]@[Link]

Année Universitaire 2025/2026

1
Plan du cours
1. Introduction
2. Les tableaux
3. Les fonctions
4. Les pointeurs
5. Les chaînes de caractères
6. Les structures
2
Chapitre 1

Introduction

3
Langages informatiques

⚫ Un langage informatique est un outil permettant de donner des

ordres (instructions) à la machine

• A chaque instruction correspond une action du processeur

⚫ Intérêt : écrire des programmes (suite consécutive

d’instructions) déstinés à effectuer une tache donnée

• Exemple: un programme de gestion de comptes bancaires

⚫ Contrainte: être compréhensible par la machine

4
Langages haut niveau

⚫ Compilateur: Traduire le programme entier une fois pour toutes

5
 Compilateurs C

⚫ Nous allons utiliser l'environnement de développement Dev-

C++ avec le système d’exploitation Windows

⚫ Vous pouvez télécharger Dev-C++ librement, par exemple sur le

site [Link]

6
Rappel : Composantes d’un programme C

7
Rappel : Les variables
⚫ Les variables servent à stocker les valeurs des données
utilisées pendant l’exécution d’un programme

⚫ Les variables doivent être déclarées avant d’être

utilisées, elles doivent être caractérisées par :

• un nom (Identificateur)
• un type (entier, réel, …)
int i, j,k;
float x, y ;
double z=1.5; // déclaration et initialisation
char c=`A`;

8
 Rappel : printf () et Scanf ()
⚫ La fonction printf est utilisée pour afficher à l’écran du texte, des valeurs
de variables ou des résultats d’expressions.

⚫ La fonction scanf permet de lire des données à partir du clavier

9
Spécificateurs de format

SYMBOLE TYPE AFFICHAGE COMME

%d ou %i int entier relatif

%u unsinged int entier naturel non signé

%c char caractère

%o int entier sous forme octale

%x ou %X int entier sous forme hexadécimale

%f float, double réel en notation décimale

%e ou %E float, double réel en notation exponentielle

%s char* chaîne de caractères

10
Rappel : L’instruction if…else

⚫ Syntaxe : If (expression)
bloc-instruction1
else
bloc-instruction2

• bloc-instruction peut être une seule instruction terminée par un point-

virgule ou une suite d’instructions délimitées par des accolades { }

Exemple: Écrire un programme en C qui demande à l’utilisateur de saisir un nombre

entier, puis affiche s’il est pair ou impair.

11
 Rappel : while et do .. while
while (condition) do
{ {
instructions instructions

} } while (condition);

⚫ La condition (dite condition de contrôle de la boucle) est évaluée à chaque

itération. Les instructions (corps de la boucle) sont exécutés tant que la condition
est vraie, on sort de la boucle dès que la condition devient fausse

12
Rappel : La boucle for

for (initialisation ; condition ; incrémentation) {

Instructions;
}

13
Chapitre 2

Les tableaux

14
 Tableaux
⚫ Un tableau est une variable structurée composée d’un nombre de variables
simples de même type désignées par un seul identificateur

⚫ Ces variables simples sont appelées éléments ou composantes du tableau,

elles sont stockées en mémoire à des emplacements contigus (l’un après
l’autre)

⚫ Le type des éléments du tableau peut être :

• simple : char, int, float, double, …
• pointeur ou structure (chapitres suivants)

Un tableau peut être: A: .....

▪ Unidimensionnel: vecteur
▪ Multidimensionnel: matrice
n composantes

15
 Déclaration des tableaux
⚫ La déclaration d'un tableau à une dimension s'effectue en précisant le type de
ses éléments et sa dimension (le nombre de ses éléments) :
type <nom_tableau> [dim]
Exemple: int T[10] ;

• Les tableaux commencent à l'indice 0 et vont à

l'indice dim-1.
• T[i] correspond au (i+1)ième élément du tableau
initialisation: se fait avec une liste des valeurs respectives, séparées par des
virgules et délimitées par les accolades int A[5] = {1, 2, 3, 4, 5};
La liste ne doit pas contenir plus de valeurs que la dimension du tableau.
Ex: short T[3] = {1, 2, 3, 4, 5}; ➔ Erreur

16
Accès aux composantes d’un tableau

⚫ L'accès à un élément du tableau se fait au moyen de l'indice. Par exemple, T[i]

donne la valeur de l'élément i du tableau T
<nom_tableau> [indice]
Remarques:
⚫ on ne peut pas saisir, afficher ou traiter un tableau en entier, ainsi on ne peut pas
écrire printf(" %d",T) ou scanf(" %d",&T)

⚫ On traite les tableaux élément par élément de façon répétitive en utilisant des
boucles
♦ La dimension d’un tableau:
La dimension d’un tableau (son nombre d’éléments) ne peut être qu’une constante
ou une expression constante.
Exemple : #define N 50
.....
int t[N] ;

17
Tableaux : saisie et affichage
⚫ Saisie des éléments d’un tableau T d’entiers de taille n :

for(i=0;i<n;i++)
{ printf ("Entrez l'élément %d \n ",i + 1);
scanf(" %d" , &T[i]);
}

⚫ Affichage des éléments d’un tableau T de taille n :

for(i=0;i<n;i++)
printf (" %d \t",T[i]);

18
Tableaux : exemple
⚫ Calcul du nombre d'étudiants ayant une note supérieure à 10 :

main ( )
{ float notes[30];
int nbre,i;
for(i=0;i<30;i++)
{ printf ("Entrez notes[%d] \n ",i);
scanf(" %f" , &notes[i]);
}
nbre=0;
for (i=0; i<30; i++)
if (notes[i]>10) nbre+=1;
printf (" le nombre de notes > à 10 est égal à : %d", nbre);

}
19
 Tableaux à deux dimensions (Matrices)
On peut définir un tableau à 2 dimensions de la façon suivante:
En langage C
type <ident> [nlig] [ncol]
Exemple:

Le tableau ident contient nlig*ncol composantes. float note[10][3];

•Les tableaux commencent aux indices 0,0 et vont aux indices nlig- 1,ncol-1.
• exemples :

float note[10][3] ;
- matrice à 10 lignes et 3 colonnes
- le premier élément de la matrice est note[0][0] et le dernier est note[9][2]

20
Initialisation à la déclaration d’une Matrice
⚫ L’initialisation lors de la déclaration se fait en indiquant la liste des valeurs
respectives entre accolades ligne par ligne

Exemple: Une matrice M[7][3] peut être représentée ainsi:

2 1 4 3 5 7 2 4 9 … … … 8 6 1

M[0][0]=2 M[1][0]=3 M[2][0]=2 M[6][0]=8

M[0][1]=1 M[1][1]=5 M[2][1]=4 M[6][1]=6
M[0][2]=4 M[1][2]=7 M[2][2]=9 M[6][2]=1

21
Matrices : saisie et affichage
⚫ Saisie des éléments d’une matrice d’entiers A[n][m] :

for(i=0;i<n;i++){
for(j=0;j<m;j++)
{ printf ("Entrez la valeur de A[%d][%d] \n ",i,j);
scanf(" %d" , &A[i][j]);
}}

⚫ Affichage des éléments d’une matrice d’entiers A[n][m] :

for(i=0;i<n;i++){
{ for(j=0;j<m;j++)
printf (" %d \t",A[i][j]);
printf("\n");
}}

22
 Tableaux : exemple

Ecrire un programme qui construit et affiche une matrice carrée unitaire U de dimension
N. Une matrice unitaire est une matrice, telle que :
1 𝑠𝑖 𝑖 = 𝑗
Uij = ቊ
0 𝑠𝑖 𝑖 ≠ 𝑗

23
 Représentation d’un tableau en mémoire
⚫ La déclaration d’un tableau provoque la réservation automatique par le
compilateur d’une zone contiguë de la mémoire.

⚫ La mémoire est une succession de cases mémoires. Chaque case est une suite
de 8 bits (1 octet), identifiée par un numéro appelé adresse.
(on peut voir la mémoire comme une armoire constituée de tiroirs numérotés. Un numéro de tiroir
correspond à une adresse)

⚫ Les adresses sont souvent exprimées en hexadécimal pour une écriture plus
compacte et proche de la représentation binaire de l’adresse. Le nombre de bits
d’adressage dépend des machines.

⚫ En C, l’opérateur & désigne adresse. Ainsi, printf(" adresse de a=

%x ", &a) affiche l’adresse de la variable a en hexadécimal

24
Représentation d’un tableau à une
dimension en mémoire
⚫ En C, le nom d'un tableau est le représentant de l'adresse du
premier élément du tableau (pour un tableau T: T=&T[0] )
1E05
T➔1E06 100

⚫ Les composantes du tableau étant stockées en mémoire à 1E08 200

des emplacements contigus, les adresses des autres
composantes sont calculées (automatiquement)
relativement à cette adresse : 1E0A 300
&T[i]= &T[0]+sizeof(type)*i
1E0C 400

⚫ Exemple : short T[5] = {100, 200, 300, 400, 500};

1E0E 500
et supposons que T=&T[0] =1E06
1E0F
⚫ On peut afficher et vérifier les adresses du tableau:
for(i=0;i<5;i++)
printf("adresse de T[%d]= %x\n",i,&T[i]);
25
 Représentation d’un tableau à deux
dimensions en mémoire

Type Description Taille (en octets)

char Caractère 1 octet
int Entier 4 octets
short int Petit entier 2 octets
long int Entier long 4 ou 8 octets
Nombre réel simple
float 4 octets
précision
Nombre réel double
double 8 octets
précision
long double Double précision étendue 8, 12 ou 16 octets
Pointeur vers n’importe quel
void * 4 ou 8 octets
type

26
Chapitre 3

Les fonctions

27
 Enoncé d’un problème

Analyse

Données résultats

Formulation de l’Algorithme

Sous- … Sous- … Sous-

programme_1 programme_k programme_n

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

28
 Fonctions
⚫ Certains problèmes conduisent à des programmes longs, difficiles à écrire et à
comprendre. On les découpe en des parties appelées sous-programmes ou modules
⚫ Les modules sont des groupes d'instructions qui fournissent une solution à des parties
bien définies d'un problème plus complexe. Ils ont plusieurs intérêts :

• La facilité de maintenance (détection facile des erreurs…)

• L'absence de répétition de séquences d'instructions

• Le partage et la réutilisation de modules (fonction)

• La structuration de programmes en sous-programmes se fait en C à l'aide des

fonctions

29
Fonctions
⚫ On définit une fonction en dehors de la fonction principale main ( ) par :

La partie déclaration de la fonction indique le type du résultat retourné par la

fonction ou void si elle ne retourne rien. Elle indique également ses paramètres
formels et leurs types si elle en admet, sinon indique void

30
 Fonctions : exemples
⚫ Une fonction qui calcule la somme de ⚫ Une fonction qui renvoie un
deux entiers x et y : entier saisi au clavier
Int Somme (int x, int y ) int RenvoieEntier( void )
{
{
int n;
return (x+y); printf (" Entrez n \n");
} scanf (" %d ", &n);
return n;
⚫ Une fonction qui affiche la somme de }
⚫ Une fonction qui affiche les
deux réels x et y : éléments d’un tableau d’entiers
void AfficheSom(double x, double y) void AfficheTab(int T[ ], int n)
{ { int i;
printf (" %lf", x+y ); for(i=0;i<n;i++) printf
} (" %d \t", T[i]);
}

31
 Fonctions
Une fonction est donc définie par :
❑ Son Nom
❑ Ses Arguments Formels
❑ Le type de la fonction (type de l'argument
retourné par la fonction)
❑ Son corps

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

32
 Fonctions

Deux Types de fonctions

1) Les fonctions qui ne retournent rien doivent être précédées par void. Ce type
de fonctions sont également appelées procédures.

Si on ne précise pas de type a une fonction, par défaut le type du résultat retourné est un entier

2) Les fonctions qui retournent quelque chose possèdent un type. Pour cela, il faut
utiliser l'instruction return

33
Appel d’une fonction
⚫ L‘appel d'une fonction se fait par simple écriture de son nom avec la liste des
paramètres. L'appel de la fonction se fait dans la fonctin main().
⚫ nom_fonction (para1,…, paraN)
⚫ Lors de l'appel d'une fonction, les paramètres sont appelés paramètres effectifs :
ils contiennent les valeurs pour effectuer le traitement. Lors de la définition, les
paramètres sont appelés paramètres formels.

34
Appel d’une fonction
Donnez le résultat de l’exécution du programme ci-dessous.

#include <stdio.h>

void carre (int n)

{
int i;
for (i=1 ; i <= n ; i++)
printf ( " Carre de %d=%d\n ", i , i*i ) ;
}

main() {

int a=5;
carre(a);
}
35
Appel d’une fonction
Donnez le résultat de l’exécution du programme ci-dessous.

• carre(a); → a est l’argument effectif

• void carre(int n) → n est le paramètre formel

36
 Déclaration des fonctions
⚫ Il est nécessaire pour le compilateur de connaître la définition d'une
fonction au moment où elle est appelée. Si une fonction est définie après
son premier appel (en particulier si elle définie après main ), elle doit être
déclarée auparavant.

La définition d'une fonction peut être effectué avant ou après celle de la fonction main.
❖ Définition Avant : la déclaration de la fonction est facultative.
❖ Définition Après : la déclaration de la fonction est obligatoire.

Type Ident_fonc (type_1 arg1, …… , Type_k argk) ;

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

Exemple: double puissance (double x, long N);

37
Déclaration des fonctions : exemple
Définir une fonction avant main() Fonction définie après main() (déclaration
obligatoire) :
#include <stdio.h>
#include <stdio.h>
// Définition de la fonction AVANT main
void direBonjour() { void direBonjour();
printf("Bonjour !\n");
} main() {
direBonjour(); // Appel de la fonction
main() { }
direBonjour(); // Appel de la fonction
// Définition APRÈS main
} void direBonjour() {
printf("Bonjour !\n");
}

38
Déclaration des fonctions : Le Prototypage

Déclarer le prototype
#include <stdio.h>

void direBonjour();

main() {
direBonjour(); Appel de la fonction
}

// Définition APRÈS main

void direBonjour() {

printf("Bonjour !\n");
} Définir la fonction

39
 Variables locales et globales
⚫ On peut manipuler 2 types de variables dans un programme C : des
variables locales et des variables globales. Elles se distinguent par ce
qu'on appelle leur portée (leur "espace de visibilité", leur "durée de vie")

➢ Variables globales
❖ Les variables globales sont des variables qui peuvent être partagées par plusieurs
fonctions (main entre autres).

❖ Elles doivent être déclarées en dehors de toute fonction.

❖ Une variable globale sera connue de toutes les fonctions qui seront compilées par la
suite au sein du même programme source.

40
 Variables locales et globales
➢ Variables locales

❖ Les variables locales sont définies au sein d’une fonction (main entre autres).
❖ Ces variables sont dites locales à la fonction dans laquelle elles sont déclarées.
❖ Les variables locales ne sont connues qu’à l’intérieur de la fonction où elles sont
déclarées.

❖ Leur portée est donc limitée à cette fonction.

❖ Une variable locale cache la variable globale qui a le même nom

41
Exemple

42
Exemple

i=3 et k=1
i=4 et k=1
i=5 et k=5

43
 Exemple

⚫ Ecrire un programme qui demande à l'utilisateur de saisir les valeurs de deux

variables A et B (locales). Ensuite, il permet de définir et d'appeler les
fonctions suivantes :
⚫ Une fonction qui retourne si les valeurs de A et B sont de même signe ou
non. (Une fonction sans valeur de retour et avec arguments)
⚫ Une fonction qui renvoie le minimum de A et B. (Une fonction avec une
valeur de retour et avec arguments)
⚫ Une fonction qui renvoie le maximum de A et B. (Une fonction avec une
valeur de retour et avec arguments)

44
Chapitre 4

Les pointeurs

45
 Pointeurs : définition
Une variable peut être représentée par une case de la mémoire, qui
contient la valeur d’une donnée et identifiée par une adresse...
int a=2;
a
……. …….
2

0xC1 0xC2 0xC3 0xC4

Mémoire centrale

Chaque variable est identifiée par:

✓ un nom avec lequel on accède à son contenu.
✓ une adresse attribuée par le système d'exploitation .

46
 Pointeurs : définition
⚫ Un pointeur est une variable spéciale qui peut contenir l’adresse d’une
autre variable. .
.
.

⚫ Exemple : Soit a une variable contenant la valeur 2 et P un 0xC2

pointeur qui contient l'adresse de a (on dit que P pointe sur P 0xA1
a) .
.
.
⚫ Remarques : .

a 0xC2
• Le nom d’une variable permet d'accéder directement 2
à sa valeur (adressage direct).

• Un pointeur qui contient l'adresse de la variable,

permet d'accéder indirectement à sa valeur (adressage mémoire
indirect).

• Le nom d'une variable est lié à la même adresse, alors

qu’un pointeur peut pointer sur différentes adresses

47
 Pointeurs : définition
Accès au contenu d'une variable

adressage direct adressage indirect

Accès au contenu par Accès au contenu à partir de

le nom de la variable l’adresse de la variable.

Pointeur

48
Déclaration d’un pointeur
⚫ En C, chaque pointeur est limité à un type de donnée (même si la valeur d’un
pointeur, qui est une adresse, est toujours un entier).

⚫ Le type d’un pointeur dépend du type de la variable pointée. Ceci est

important pour connaître la taille de la valeur pointée.

⚫ On déclare un pointeur par l’instruction : type *nom-du-pointeur ;

• type est le type de la variable pointée
• * est l’opérateur qui indiquera au compilateur que c’est un pointeur
• Exemple :
int *pi; //pi est un pointeur vers une variable de type int
float *pf; //pf est un pointeur vers une variable de type float

49
Opérateurs de manipulation des pointeurs
⚫ Lors du travail avec des pointeurs, nous utilisons :
• un opérateur 'adresse de': & pour obtenir l'adresse d'une variable
• un opérateur 'contenu de': * pour accéder au contenu d'une adresse

Récupération d’adresse d’une Récupération (ou modification) de

variable avec L’opérateur "&" donnée d’une variable avec L’opérateur
("adresse de") "*" ("contenu de")

int a, *P;
P =&a;
« P pointe sur a »
a = 1;
*P = 2;
50
Opérateurs de manipulation des pointeurs
⚫ Exemple2 : float a, *p;
p=&a;
printf("Entrez une valeur : \n");
scanf("%f ",p); //supposons qu’on saisit la valeur 1.5
printf("Adresse de a= %x, contenu de a= %f\n" , p,*p);
*p+=0.5;
printf ("a= %f\n" , a); //affiche a=2.0

⚫ Remarque : si un pointeur P pointe sur une variable X, alors *P peut

être utilisé partout où on peut écrire X
• X+=2 équivaut à *P+=2
• ++X équivaut à ++ *P
• X++ équivaut à (*P)++ // les parenthèses ici sont obligatoires car
l’associativité des opérateurs unaires * et ++ est de droite à gauche

51
 Initialisation d’un pointeur
⚫ A la déclaration d’un pointeur p, on ne sait pas sur quel zone mémoire il pointe.
Ceci peut générer des problèmes :
• int *p;
*p = 10; //provoque un problème mémoire car le pointeur p n’a pas été initialisé

⚫ NP : 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 (Ex: int a, *p1; p1=&a; )

• un autre pointeur déjà initialisé (Ex: int *p2; p2=p1;)
• la valeur 0 désignée par le symbole NULL, défini dans <stddef.h>.
Ex: int *p; p=0;ou p=NULL; (on dit que p pointe ‘nulle part’: aucune
adresse mémoire ne lui est associé)
⚫ Rq: un pointeur peut aussi être initialisé par une allocation dynamique.

52
Pointeurs : exercice
main()
{ int A = 1, B = 2, C = 3, *P1, *P2;
P1=&A;
P2=&C;
*P1=(*P2)++;
P1=P2;
P2=&B;
*P1-=*P2;
++*P2;
*P1*=*P2;
A=++*P2**P1;
P1=&A;
}
Donnez les valeurs de A, B,C,P1 et P2 après chaque instruction

53
main() {
int A = 1, B = 2, C = 3; int *P1, *P2; // Déclaration de deux pointeurs

P1 = &A; // P1 pointe vers A

P2 = &C; // P2 pointe vers C

*P1 = (*P2)++; // *P1 (donc A) reçoit la valeur de C (3), puis C devient 4

// A = 3 ; C = 4

P1 = P2; // P1 pointe maintenant vers C

P2 = &B; // P2 pointe vers B

*P1 -= *P2; // *P1 (donc C) devient C - B = 4 - 2 = 2

++*P2; // Incrémentation de B ? B devient 3

*P1 *= *P2; // *P1 (C) devient C × B = 2 × 3 = 6

A = ++*P2 * *P1; // B est incrémenté (donc 4), puis A = B × C = 4 × 6 = 24

P1 = &A; // P1 pointe à nouveau vers A

}

54
 Donnez les valeurs de A, B,C,P1 et P2 après chaque instruction

Instruction A B C *P1 *P2 P1 P2

Initialisation 1 2 3 - - - -

P1 = &A; 1 2 3 1 - &A -

P2 = &C; 1 2 3 1 3 &A &C

*P1 = (*P2)++; 3 2 4 3 4 &A &C

P1 = P2; 3 2 4 4 4 &C &C

P2 = &B; 3 2 4 4 2 &C &B
*P1 -= *P2; 3 2 2 2 2 &C &B
++*P2; 3 3 2 2 3 &C &B

*P1 *= *P2; 3 3 6 6 3 &C &B

55
Exemple
⚫ Écrire un programme qui déclare un entier x, un pointeur p, puis :
⚫ Affecte à p l’adresse de x.
⚫ Change la valeur de x à travers le pointeur.
⚫ Affiche la nouvelle valeur de x.

56
 Pointeurs et tableaux
⚫ En C, le nom d'un tableau est le représentant de l'adresse du premier élément du
tableau (pour un tableau T: T=&T[0] ) Avec le formalisme pointeur, on peut dire que T
est un pointeur constant sur le premier é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]) et crée une liaison entre P et le tableau T.

Soit un tableau T de type entier: int T[10];

T[0] T[1] T[2] ……………. T[9]

P pointe sur T[0] et *P désigne T[0]

P+i pointe sur T[i] et *(P+i) désigne T[i]
printf("%d",*T); ou printf("%d" ,T[0]); ou printf("%d" ,*P);
scanf("%d" ,T+2); ou scanf("%d",&T[2]); ou scanf("%d" ,(P+2));
 Pointeurs et tableaux : Exemple
⚫ Exemple: Int x, A[7]={5,0,9,2,1,3,8};
Int *P;
P=A;
x=*(P+5);

⚫ Le compilateur obtient l'adresse P+5 en ajoutant 5*sizeof(int) = 10 octets à

l'adresse dans P

⚫ Ainsi, x est égale à la valeur de A[5] (x= A[5]=3)

58
Pointeurs : saisie et affichage d’un
tableau
main() {
int T[100], *pt;
int i, n;
do { // Saisie de la taille du tableau
printf("Entrez n (0 < n ≤ 100) : ");
scanf("%d", &n);
} while(n <= 0 || n > 100);

pt = T; // Le pointeur pointe sur le tableau

for(i = 0; i < n; i++) { // Saisie des éléments

printf("Entrez T[%d] : ", i);
scanf("%d", pt + i);
}
printf("Contenu du tableau :\n"); // Affichage des éléments
for(i = 0; i < n; i++) {
printf("%d\t", *(pt + i));
}
}
59
 Pointeurs : saisie et affichage d’un
tableau
Exemple1 Exemple2

main() main()
{ {
int T[5] = {-3, 4, 0, -7, 3}; int T[5] = {-3, 4, 0, -7, 3};
int A[5]; int A[5];
int I,J; int I,J;
for (J=0, I=0 ; I<5 ; I++) for (J=0,I=0 ; I<5 ; I++)
if (T[I]>0) if (*(T+I)>0)
{ {
A[J] = T[I]; *(A+J) = *(T+I);
J++; J++;
} }
} }

60
Pointeurs et tableaux à deux dimensions
⚫ Le nom d'un tableau A à deux dimensions est un pointeur constant sur le
premier élément du tableau càd A[0][0].

⚫ En déclarant un tableau A[n][m] et un pointeur P du même type, on peut

manipuler le tableau A en utilisant le pointeur P en faisant pointer P sur le
premier élément de A (P=&A[0][0]), Ainsi :

• P pointe sur A[0][0] et *P désigne A[0][0]

• P+1 pointe sur A[0][1] et *(P+1) désigne A[0][1]
• ….
• P+M pointe sur A[1][0] et *(P+M) désigne A[1][0]
• ….
• P+i*M pointe sur A[ i][0] et *(P+i*M) désigne A[i][0]
• ….
• P+i*M+j pointe sur A[ i][ j] et *(P+i*M+j) désigne A[i][j]

61
Pointeurs : saisie et affichage d’une
matrice
#define N 3
#define M 3
main( ) {
int i, j, A[N][M], *pt;
pt=&A[0][0];
for(i=0;i<N;i++)
for(j=0;j<M;j++)
{ printf ("Entrez A[%d][%d]\n ",i,j );
scanf(" %d" , pt+i*M+j); // &A[i][j]===pt+i*M+j
}

for(i=0;i<N;i++)
{ for(j=0;j<M;j++)
printf (" %d \t",*(pt+i*M+j)); //*(pt+i*M+j))====A[i][j]
printf ("\n");
}
}
62
 Pointeurs et tableaux : remarques
En C, on peut définir :

⚫ Un tableau de pointeurs :
Ex : int *T[10]; //déclaration d’un tableau de 10 pointeurs d’entiers

⚫ Un pointeur de tableaux :
Ex : int (*pt)[20]; //déclaration d’un pointeur sur des tableaux de 20
éléments

⚫ Un pointeur de pointeurs :
Ex : int **pt; //déclaration d’un pointeur pt qui pointe sur des pointeurs
d’entiers

63
Allocation dynamique de mémoire
La déclaration d’un tableau définit un tableau "statique": il possède un
nombre figé d’emplacements.

Il y a donc un gaspillage d’espace mémoire en réservant toujours

l’espace maximal prévisible.

Il faut donc un moyen pour allouer la mémoire lors de l'exécution du

programme : c’est l’allocation dynamique de mémoire

64
 La fonction malloc
⚫ La fonction malloc de la bibliothèque <stdlib> permet de localiser et de
réserver de la mémoire, sa syntaxe est : malloc(N)
⚫ Cette fonction retourne un pointeur de type char * pointant vers le
premier octet d’une zone mémoire libre de N octets ou le pointeur
NULL s’il n’y a pas assez de mémoire libre à allouer.

⚫ Exemple : Si on veut réserver la mémoire pour un texte de 1000

caractères, on peut déclarer un pointeur pt sur char (char *pt).
• L'instruction: T = malloc(1000); fournit l'adresse d'un bloc de 1000 octets libres
et l'affecte à T. S'il n'y a pas assez de mémoire, T obtient la valeur zéro (NULL).

⚫ Remarque : Il existe d’autres fonctions d’allocation dynamique de

mémoire dans la bibliothèque <stdlib>

65
 La fonction malloc
Utilisation des fonctions de la bibliothèque <stdlib.h>
malloc ( N):

Fournit l'adresse d'un bloc mémoire de N octets libres ou

la valeur zéro sinon.
(int *) malloc(N*sizeof(int)):
Fournit l'adresse d'un bloc mémoire de N*sizeof(int)
octets libres pour déposer des entiers, ou la valeur zéro
sinon.
int * A;
A= (int *)malloc(N*sizeof(int)):
mémorisation dans A l’adresse retournée par la
fonction malloc.

66
 La fonction malloc et free
⚫ Si on veut réserver de la mémoire pour des données qui ne sont pas de type
char, il faut convertir le type de la sortie de la fonction malloc à l’aide d’un
cast.

⚫ Exemple : on peut réserver la mémoire pour 2 variables contiguës de

type int avec l’instruction : p = (int*)malloc(2 * sizeof(int)); où p est un
pointeur sur int (int *p).

⚫ Si on n'a plus besoin d'un bloc de mémoire réservé par malloc, alors on
peut le libérer à l'aide de la fonction free , dont la synatxe est :
free(pointeur);

⚫ 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.

67
malloc et free : exemple

68
Fonctions et pointeur: Paramètres d'une fonction
⚫ Les paramètres servent à échanger des informations entre la fonction
appelante et la fonction appelée. Ils peuvent recevoir des données et
stocker des résultats

⚫ Il existe deux modes de transmission de paramètres dans les

langages de programmation :
• La transmission par valeur : les valeurs des paramètres effectifs sont
affectées aux paramètres formels correspondants au moment de l'appel de la
fonction ou procédure. Dans ce mode le paramètre effectif ne subit aucune
modification

• La transmission par adresse (ou par référence) : les adresses des

paramètres effectifs sont transmises à la fonction appelante. Dans ce mode,
le paramètre effectif subit les mêmes modifications que le paramètre formel

69
 Exemple
Par valeur Par Adresse
#include <stdio.h>
#include <stdio.h>
void changer(int x) {
void changer(int *x) {
x = 10; // modifie la copie
*x = 10; // modifie la valeur à
}
l'adresse envoyée
}
int main() {
int a = 5;
int main() {
changer(a);
int a = 5;
printf("a = %d\n", a); // a reste 5
changer(&a);
return 0;
printf("a = %d\n", a); // a devient 10
}
return 0;
}

70
 Transmission des paramètres en C
⚫ La transmission des paramètres en C se fait toujours par valeur
⚫ Pour effectuer une transmission par adresse en C, on déclare le paramètre
formel de type pointeur et lors d'un appel de la fonction, on envoie
l'adresse et non la valeur du paramètre effectif

Méthode Effet sur les variables originales

Par valeur Ne change pas les valeurs dans main()
Par adresse/pointeur Modifie les vraies valeurs dans main()

71
 Exemple
Par valeur Par Adresse
#include <stdio.h>
#include <stdio.h>
void permuter(int a, int b) {
void permuter(int *a, int *b) {
int temp = a;
int temp = *a;
a = b;
*a = *b;
b = temp;
*b = temp;
printf("Dans la fonction : a = %d, b = %d\n", a, b);
}
}
int main() {
main() {
int x = 5, y = 10;
int x = 5, y = 10;
permuter(&x, &y);
permuter(x, y);
// Changé
// Pas changé
printf("Après permutation : x = %d, y = %d\n", x, y);
printf("Dans le main : x = %d, y = %d\n", x, y);
}
}

72
 Exemple

À l'aide de pointeurs, écrivez un programme qui demande à l'utilisateur de

remplir un tableau de 6 éléments, puis le programme calcule et affiche la
somme des éléments.

73
 Chapitre 5

Les Chaînes de caractères

74
 Chaînes de caractères
⚫ Il n'existe pas de type spécial chaîne ou string en C. Une chaîne de
caractères est traitée comme un tableau de caractères

⚫ Une chaîne de caractères en C est caractérisée par le fait que le dernier

élément vaut le caractère ‘\0’, ceci permet de détecter la fin de la chaîne

⚫ Il existe plusieurs fonctions prédéfinies pour le traitement des chaînes de

caractères (ou tableaux de caractères )

75
 Déclaration
⚫ Syntaxe : char <NomVariable> [<Longueur>]; //tableau de caractères

Exemple : char NOM [15];

⚫ 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 aussi manipuler les chaînes de caractères en utilisant des pointeurs

(de la même façon qu'un pointeur sur int peut contenir l'adresse d'un élément d'un
tableau d’entiers, un pointeur sur char peut pointer sur les éléments d'un tableau de
caractères)

76
 Initialisation
⚫ On peut initialiser une chaîne de caractères à la définition :

• comme un tableau, par exemple : char ch[ ] = {‘h’,’e’,’l’,’l’,’o’,’\0’}

• par une chaîne constante, par exemple : char ch[ ] = "hello“
• en attribuant l'adresse d'une chaîne de caractères constante à un pointeur sur
char, par exemple : char *ch = "hello“

⚫ On peut préciser le nombre d'octets à réserver à condition que celui-ci soit

supérieur ou égal à la longueur de la chaîne d'initialisation

• char ch[ 6] = "hello“ est valide

• char ch[ 4] = "hello“ ou char ch[ 5] = "hello“ provoque une erreur

77
 Fonctions de la bibliothèque <stdio.h>
⚫ printf( ) : permet d’afficher une chaîne de caractères en utilisant le
spécificateur de format %s.

Exemple : char ch[ ]= " Bonsoir " ;

printf(" %s ", ch);

⚫ puts( ch): affiche la chaîne de caractères

Exemple : char *ch= " Bonsoir " ;

puts(ch); /*équivalente à printf("%s\n ", ch);*/

78
 Fonctions de la bibliothèque <stdio.h>
⚫ scanf( ) : permet de saisir une chaîne de caractères en utilisant le
spécificateur de format %s.

Exemple : char Nom[15];

printf("entrez votre nom");
scanf(" %s ", Nom);
Remarque : le nom d'une chaîne de caractères est le représentant de l'adresse du
premier caractère de la chaîne, il ne doit pas être précédé de &

⚫ gets( <chaine>) : lit la chaîne de caractères désignée par <Chaîne>

Exemple : char phrase[100];

printf("entrez une phrase");
gets(phrase);

79
 Traitement des chaînes de caractères
⚫ Le langage C dispose d’un ensemble de bibliothèques qui contiennent des
fonctions spéciales pour le traitement de chaînes de caractères

⚫ Les principales bibliothèques sont :

• La bibliothèque <stdio.h>

• La bibliothèque <string.h>

• La bibliothèque <stdlib.h>

80
 Fonctions de la bibliothèque <string.h>
⚫ strlen(ch): fournit la longueur de la chaîne sans compter le '\0' final
Exemple : char s[ ]= " Test";
printf(“%d”,strlen(s)); //affiche 4

⚫ strcat(ch1, ch2) : ajoute ch2 à la fin de ch1. Le caractère ‘\0’ de ch1 est
écrasé par le 1er caractère de ch2

Exemple : char ch1[20]=" Bonne ", ch2=" chance ";

strcat(ch1, ch2) ;
printf(" %s", ch1); // affiche Bonne chance

81
 Fonctions de la bibliothèque <string.h>
⚫ strcmp(ch1, ch2): compare ch1 et ch2 lexicographiquement et
retourne une valeur : - nul si ch1 et ch2 sont identiques
- négative si ch1 précède ch2
- positive si ch1 suit ch2

⚫ strcpy(ch1, ch2) : copie ch2 dans ch1 y compris le caractère ‘\0’

Exemple : char ch[10];

strcpy(ch, " Bonjour ");
puts(ch); // affiche Bonjour
⚫ strchr(char *s, char c) : recherche la 1ère occurrence du caractère c dans la
chaîne s et retourne un pointeur sur cette 1ère occurrence si c’est un caractère
de s, sinon le pointeur NULL

82
Chapitre 6

Les structures

83
 Introduction

Comme le cas d’un tableau, une structure permet de ranger un

ensemble d'informations.

• un tableau regroupe sous un même nom un ensemble de variables de même

type, repérées par leur indice.

• la structure, elle, regroupe sous un même nom des variables de types

différents. Chaque élément (variable) de la structure (appelé champ) est
désigné par un nom qui permet d'y avoir accès.

84
Introduction

Une structure est :

❑ Un Type de données du langage C
❑ Constitué de plusieurs éléments, appelés champs ou membres.
❑ Chaque membre a un nom et un type.
❑ Chaque membre peut être de type différent.

Intérêt : Regrouper des données hétérogènes caractérisant

une entité pour en faire un seul type utilisateur.

Rôle: Le rôle d'une variable structurée est de ranger en mémoire,

sous une forme bien ordonnée (bien "structurée"), toutes les
informations se rapportant à un objet.

85
Déclaration

Syntaxe de la définition d'une structure.

#include <stdio.h>

struct nom_structure
{ Déclaration de base du
modèle formel de la
type1 nom_champs1; structure avec le mot clé
type2 nom_champs2; struct et non la variable.
type3 nom_champs3, nom_champs4;
};

Placer entre les accolades

les variables dont est
composée votre structure.

86
 Déclaration: Déclaration avec une variable

Exemple de structure de données décrivant un livre par son titre, son auteur, son
éditeur, son nombre de pages, son année d’édition et son prix.
Forme 1:
Définition de la structure par l'identificateur de la variable
struct LIVRE Déclaration du type de la structure du Nom
{ LIVRE
char titre[80];
char auteur[40]; Déclaration d’une variable de type structure
char editeur[40]; de nom LIVRE
int nombre_pages;
int annee_edition; La variable livre1: comporte plusieurs membres
double prix; (sous variables)

} livre1; ❑ De type différent.

❑ Identifié par un nom.

87
Déclaration: Déclaration simple (sans
variable)
Forme 2:
Déclaration de la structure en lui donnant un nom, puis on déclare les variables

struct LIVRE Déclaration de Nom du type structure

{
char titre[80];
char auteur[40]; Réutilisation de Nom du type pour
char editeur[40]; déclarer des variables
int nombre_pages;
int annee_edition;
double prix; struct LIVRE livre1, livre2;
};

Le mot struct doit être répété lors de l‘utilisation du type

88
Déclaration: Déclaration simple (sans
variable)
Exemple de structure permettant de représenter des points à l’aide de leur
nom et de leurs coordonnées x et y.

struct Tpt
{
char nom;
int x;
int y;
};
struct Tpt M;
struct Tpt N;

89
 Déclaration: typedef

typedef permet de renommer une structure pour simplifier son utilisation, en

évitant d’écrire le mot-clé struct à chaque fois
Syntaxe :
typedef struct Le mot-clé typedef permet de définir un nouveau type.
{
char titre[80];
char auteur[40];
char editeur[40];
int nombre_pages; Ici, il s’agit bien du nom du type,
int annee_edition; et non pas d’une variable
double prix;
} LIVRE; Déclaration de variables avec le nouveau type créé

LIVRE livre1;
Cela permet d'éviter d'écrire le mot struct à chaque utilisation
90
Utilisation d'une structure

Opérations sur les champs

Deux opérateurs spécifiques, '.' (point) et '->' (flèche), sont utilisés pour accéder
aux membres d'une structure. L'opérateur '.' sert à un accès direct, tandis que '->'
est employé pour un accès indirect via un pointeur.
Exemple:

typedef struct Accès direct au membre "prix" de la variable structurée "livre1":

{ char titre[80]; Utilisation de L'opérateur '.'
char auteur[40];
char editeur[40];
[Link]=450;
int nombre_pages;
int annee_edition; livre1. nombre_pages =400;
double prix;
} LIVRE;
LIVRE livre1;

91
 Utilisation d'une structure

Utilisation de l’Opérateur point : "."

#include <stdio.h>

typedef struct {
char titre[30];
char auteur[30];
int pages;
} LIVRE;

main() {

LIVRE livre1 = { "Morocco", "mohamed", 328 };

printf("Titre : %s\n", [Link]);
printf("Auteur : %s\n", [Link]);
printf("Nombre de pages : %d\n", [Link]); }

92
Utilisation d'une structure

#include <stdio.h>
#include <string.h>
typedef struct {
char titre[30];
char auteur[30];
int pages;
} LIVRE;

int main() {
LIVRE livre1;
strcpy([Link], "Mohamed");
strcpy([Link], "Morocco"); [Link] = 50;

printf("Titre : %s\n", [Link]);

printf("Auteur : %s\n", [Link]);
printf("Nombre de pages : %d\n", [Link]);}

93
 Tableaux de structures

Étant donné que le mot clé struct définit un type, il est tout à fait possible de créer
des tableaux contenant des structures du même type.

❖ La structure point permet de représenter un point dans

un plan à l’aide : struct point {
char nom;
- d’un nom (caractère), int x;
- de ses deux coordonnées x et y (entiers). int y;
};
❖ La déclaration struct point courbe[5]; permet de créer
struct point courbe[5];
un tableau de 5 points, c’est-à-dire 5 éléments de type
point.

94
 Tableaux de structures

Pour accéder ou modifier les valeurs :

courbe[i].nom : le nom du iᵉ point

Initialisation partielle d’un tableau
courbe[i].x : sa coordonnée x struct point courbe[5] = {
{'A', 10, 25},
courbe[i].y : sa coordonnée y {'B', 12, 18},
{'C', 20, 30},..
Lecture au clavier };

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

printf("Donner le nom, x et y du point %d : ", i + 1);
scanf(" %c %d %d", &courbe[i].nom, &courbe[i].x, &courbe[i].y);
}

95
Tableaux de structures

Exemple: la structure point

96
Tableaux de structures
Exemple: la structure LIVRE

97