Licence d'études fondamentales :

Sciences Mathématiques et Informatiques - SMI / S4 -

M21 – Programmation 2
Pr. Otman ABDOUN
Département Informatique
Faculté des Sciences, Tétouan
Année Universitaire : Université Abdelmalek Essaadi
2021 -2022
Plan du Module
M21 : Programmation 2

1. Pointeurs et Allocation dynamique

2. Les chaines de caractères
3. Les fonctions
4. Types composés (structures, unions, synonymes)
5. Les fichiers

|
Pr. Otman ABDOUN M21. Programmation 2 SMI – S4 2021 / 2022 2
 Pointeurs et
Allocation dynamique
Chapitre 1 :

Pr. Otman ABDOUN M21. Programmation 2

2021 / 2022 3
SMI – S4
 Chapitre 1 : Pointeurs et Allocation dynamique
1.1 Pointeurs : Introduction

• Toute variable manipulée dans un programme

est stockée quelque part en mémoire centrale.
• Cette mémoire est constituée d'octets qui sont
identifiés de manière univoque par un numéro
qu'on appelle adresse.
• Pour retrouver une variable, il suffit donc de
connaître l'adresse de l'octet où elle est stockée
• Les variables par des identificateurs (Nom : i ),
et non par leur adresse. 62FE4C
17

i
Pr. Otman ABDOUN M21. Programmation 2 SMI – S4 2021 / 2022 4
 Chapitre 1 : Pointeurs et Allocation dynamique
1.1 Pointeurs : Adresse et valeur d’une variable

• On appelle variable tout objet pouvant être placé à gauche d'un opérateur d'affectation.
• Une variable est caractérisée par :
• son adresse, c'est-à-dire l'adresse-mémoire à partir de laquelle l'objet est stocké ;
• sa valeur, c'est-à-dire ce qui est stocké à cette adresse.
• Dans l'exemple,
int i, j ;
i=3;
j=i;
Si le compilateur a placé la variable i à l'adresse 4831836000 en mémoire, et la variable j à
l'adresse 4831836004, on a :
Variable Adresse Valeur
i 4831836000 3
j 4831836004 3

Pr. Otman ABDOUN M21. Programmation 2 SMI – S4 2021 / 2022 5

 Chapitre 1 : Pointeurs et Allocation dynamique
1.1 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)
i=17

&i = 62FE44

• En accédant à cette adresse, on peut accéder indirectement à

la variable et donc la modifier. Un pointeur est une adresse mémoire.
Le pointeur P pointe vers i, puisque P
17 pointe vers l’emplacement mémoire où est
62FE44
enregistrée i.
Pr. Otman ABDOUN P M21. Programmation 2 i SMI – S4 2021 / 2022 6
 Chapitre 1 : Pointeurs et Allocation dynamique
1.1 Pointeurs : Définition, Déclaration & Initialisation
• Un pointeur est une variable dont la valeur est égale à l'adresse d'un autre objet.

• On déclare un pointeur par l'instruction :

type *nom_du_pointeur ;
où type est le type de la variable pointée.
• Cette déclaration déclare un identificateur, nom_du_pointeur, associé à une variable dont la
valeur est l'adresse d’une autre variable de type type.
• L'identificateur nom_du_pointeur est donc en quelque sorte un identificateur d'adresse.
Comme pour n'importe quelle variable, sa valeur est modifiable.

• Initialisation d’un pointeur : nom_du_pointeur = &Variable ;

• Dans l'exemple suivant, on définit un pointeur P qui pointe vers une variable entier i :
int i = 3 ; Variable Adresse Valeur
int *P ;
P = &i ; i 4831836000 3
P 4831836004 4831836000
Pr. Otman ABDOUN M21. Programmation 2 SMI – S4 2021 / 2022 7
 Chapitre 1 : Pointeurs et Allocation dynamique
1.1 Pointeurs : Déclaration de Pointeurs (Exemples)
• Le symbole * est utilisé entre le type et le nom du pointeur : type * 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 */

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 */

Pr. Otman ABDOUN M21. Programmation 2 SMI – S4 2021 / 2022 8

 Chapitre 1 : Pointeurs et Allocation dynamique
1.1 Pointeurs : Opérateur Contenu *
• L'opérateur Contenu * permet d'accéder directement à la valeur de l'objet pointé.

• Si P est un pointeur vers un entier i : P = &i ;

*P désigne la valeur de i >>>> *P, c’est le contenu de la variable i

• Par exemple, le programme Variable Adresse Valeur

main()
i 4831836000 3
{
int i = 3; P 4831836004 4831836000
int *P; *P 4831836000 3
Dans le programme, les Variables i et *P sont identiques :
P = &i; elles ont mêmes Adresse et Valeur.
printf(" *P = %d \n ", *P );
Cela signifie en particulier que toute modification de *P
} modifie i.

Affichage de l’exécution : *P = 3 Si l'on ajoute l'instruction *P = 0; à la fin du programme

précédent, la valeur de i devient nulle.
Pr. Otman ABDOUN M21. Programmation 2 SMI – S4 2021 / 2022 9
 Chapitre 1 : Pointeurs et Allocation dynamique
1.1 Pointeurs : Arithmétiques =
• Dans un programme, c’est possible de manipuler à la fois les objets P et *P.
• Ces deux manipulations sont très différentes.
• Comparons par exemple les deux programmes suivants :
main() • Avant la dernière affectation de chacun de main()
{ ces programmes, on est dans une {
int i = 3, j = 6; configuration du type : int i = 3, j = 6;
int *P1, *P2; Variable Adresse Valeur int *P1, *P2;
P1 = &i; i 4831836000 3 P1 = &i;
P2 = &j; j 4831836004 6 P2 = &j;
*P1 = *P2 ; P1 4831835984 4831836000 P1 = P2 ;
} P2 4831835992 4831836004 }

Après l'affectation *P1 = *P2 ; Après l'affectation P1 = P2 ;

du premier programme, on a du premier programme, on a
Variable Adresse Valeur Variable Adresse Valeur
i 4831836000 6 i 4831836000 3
j 4831836004 6 j 4831836004 6
P1 4831835984 4831836000 P1 4831835984 4831836004
P2 4831835992 4831836004 P2 4831835992 4831836004
Pr. Otman ABDOUN M21. Programmation 2 SMI – S4 2021 / 2022 10
 Chapitre 1 : Pointeurs et Allocation dynamique
1.1 Pointeurs : Exercice
Copiez le tableau suivant et complétez-le pour chaque instruction du programme ci-dessus:
main()
{
A B C P1 P2 Equivalant
int A = 1, B = 2, C = 3;
Init. 1 2 3 / / Init.
int *P1, *P2;
P1 = &A 1 2 3 &A / P1 = &A
P1=&A;
P2 = &C 1 2 3 &A &C P2 = &C
P2=&C;
*P1=(*P2)++; *P1 = (*P2)++ 3 2 4 &A &C A = C++

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

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

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

++*P2; ++*P2 3 3 2 &C &B ++B
*P1*=*P2; *P1 *= *P2 3 3 6 &C &B C *= B
A=++*P2**P1; A =++*P2 * *P1 24 4 6 &C &B A = ++B * C
P1=&A; P1 = &A 24 4 6 &A &B P1 = &A
*P2=*P1/=*P2; *P2=*P1 /= *P2 6 6 6 &A &B B = A /= B
}

Pr. Otman ABDOUN M21. Programmation 2 SMI – S4 2021 / 2022 11

 Chapitre 1 : Pointeurs et Allocation dynamique
1.1 Pointeurs : Exercice
Copiez le tableau suivant et complétez-le pour chaque instruction du programme ci-dessus:
main()
{
A B C P1 P2 Equivalant
int A = 1, B = 2, C = 3;
Init. 1 2 3 / / Init.
int *P1, *P2;
P1 = &A 1 2 3 &A / P1 = &A
P1=&A;
P2 = &C 1 2 3 &A &C P2 = &C
P2=&C;
*P1=(*P2)++; *P1 = (*P2)++ 3 2 4 &A &C A = C++

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

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

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

++*P2; ++*P2 3 3 2 &C &B ++B
*P1*=*P2; *P1 *= *P2 3 3 6 &C &B C *= B
A=++*P2**P1; A =++*P2 * *P1 24 4 6 &C &B A = ++B * C
P1=&A; P1 = &A 24 4 6 &A &B P1 = &A
*P2=*P1/=*P2; *P2=*P1 /= *P2 6 6 6 &A &B B = A /= B
}

Pr. Otman ABDOUN M21. Programmation 2 SMI – S4 2021 / 2022 12