SDD M3-Etd

STRUCTURES DE DONNÉES
EN LANGAGE C
Dr MAHAMAT HABIB SENOUSSI HISSEIN

LES FONCTIONS
Une fonction est un bloc de code C indépendant, référencé par un nom, qui réalise une tâche
précise et qui peut renvoyer une valeur au programme qui l’a appelée.
Ce nom est unique

Quand ce programme appelle la fonction, le code de cette fonction est exécuté
Une seule de ces fonctions existe obligatoirement; c’est la fonction principale appelée main. Cette
fonction principale peut, éventuellement, appeler une ou plusieurs fonctions secondaires.
Dr MAHAMAT HABIB SENOUSSI HISSEIN 2

LES FONCTIONS
❑ Prototype de la fonction
type_retour nom_fonction (type_arg –1, ..., type_arg –n);
❑ Définition d’une fonction
La définition d’une fonction est la donnée du texte de son algorithme, qu’on appelle corps de la fonction.
Elle est de la forme :
type nom-fonction ( type-1 arg-1,..., type-n arg-n)
{
[ déclarations de variables locales ]
liste d’instructions
}
arg-1,..., arg-n : les arguments de la fonction sont appelés paramètres formels.
Par opposition aux paramètres effectifs qui sont les paramètres avec lesquels la fonction est effectivement
appelée.
3
EXEMPLES DE PROTOTYPES ET DÉFINITIONS
Exemples de définitions
double carré (double nombre) /* en-tête de fonction */

{ /* accolade de début */
return (nombre * nombre); /* corps de la fonction */
} /* accolade de fin */

EXEMPLES : LES PARAMÈTRES EFFECTIFS & FORMELS

FONCTIONS SANS RETOUR (PROCÉDURES)
On appelle procédure ou fonction sans retour, toutes fonctions ayant le type void comme type
de retour.
Exemple :
void ma_fonction(....);
void affiche_n_hello(int n)
{
int i;
for (i=0; i<n; i++)
printf("hello");
return;
}

LES FONCTIONS
❑ Appel d’une fonction
L’appel d’une fonction se fait par l’expression

nom-fonction( para-1, para- 2,..., para-n )
L’ordre et le type des paramètres effectifs de la fonction doivent concorder avec ceux donnés dans
l’en-tête de la fonction.
Le corps de la fonction se termine par l’instruction de retour à la fonction appelante en utilisant le

mot clé return

LES FONCTIONS
int produit(int a, int b)

{
int resultat;
resultat = a * b;
return(resultat);
}

LE PLACEMENT DES FONCTIONS
Structure d’un programme qui utilise des fonctions.
9
EXEMPLE FONCTIONS
void echange (int a, int b)
{ imprime
int t; début programme principal :
printf("début fonction :\n a = %d \t b = %d\n", a, b);
a=2b=5
t = a;
début fonction :
a = b;
b = t; a=2b=5
printf("fin fonction :\n a = %d \t b = %d\n", a, b); fin fonction :
return; a=5b=2
}
main()
{
int a = 2, b = 5;
printf("debut programme principal :\n a = %d \t b = %d\n", a, b);
echange(a, b);
printf("fin programme principal :\n a = %d \t b = %d\n", a, b);
}
EXEMPLE FONCTIONS
#include <stdio.h>
int add (int x, int y)

{
int z;
z = x + y;
return (z);
}
main ()
{
int i, j, k;
i = 10;
j = 20;
k = add(i, j);
printf (" La valeur de k est %d\n", k);
}
La valeur de k est 30
11
LE PASSAGE DE PARAMÈTRES
Lors de l’appel d’un sous-programme, il est possible de transmettre des données du module
appelant vers
le module appelé de deux manières différentes :
❖ le passage par valeur : seule une copie des valeurs des paramètres effectifs est reçue par
le sous programme,
❖ le passage par adresse : l’adresse en mémoire du paramètre effectif est reçue par
le sous programme.
12
LE PASSAGE PAR VALEUR
void permuter(int a, int b)
{
int temp;
printf ("Avant permutation la valeur de a est %d et de b est %d",a,b) ;
temp =a ;
a=b ;
b= temp ;
printf ("Après permutation la valeur de a est %d et de b est %d",a,b) ;
}
Void main( )
{
int a = 10 ;
int b = 200 ;
permuter (a, b) ;
printf ("la valeur de a est %d et de b est %d",x,y) ;
}
13
LE PASSAGE PAR ADRESSE
Dans ce type de passage, la procédure utilise l'adresse du paramètre effectif.
Lorsqu'on utilise l'adresse du paramètre, on accède directement à son contenu. La
valeur de la variable effectif sera donc modifiée.
#include <stdio.h>
#include <stdlib.h>
void Echange(int *p1, int *p2)
{
int temp = *p1;
*p1 = *p2;
*p2 = temp;
}
void main()
{
int n=2, m=5;
Echange(&n, &m);
printf("n=%d \t m=%d \n",n,m);
}
14
PASSER UN TABLEAU EN PARAMÈTRE D’UNE FONCTION
considérons la fonction suivante, qui prend un tableau comme un argument et leur taille, et elle retourne la
moyenne
double moyenne(int tab[ ], int taille)

{
int i;
double moy;
double sum = 0;
for (i = 0; i < taille; ++i)
{
sum += tab[i];
}
moy = sum / taille;
return moy;
}
15
TYPES COMPOSÉS : LES TABLEAUX
Un tableau est un ensemble fini d’éléments de même type, stockés en mémoire à des
adresses contiguës.
La déclaration d’un tableau à une dimension se fait de la façon suivante :
type nom-du-tableau[nombre-éléments];
nombre-éléments / taille du tableau : est une expression constante entière positive.
16
Exemple :
int tab[10]; indique que tab est un tableau de 10 éléments de type int.
Cette déclaration alloue donc en mémoire pour l’objet tab un espace de 10 × 4
octets consécutifs.
char tab_char [10]; /* Déclaration d'un tableau de 10 caractères */
int tab_int [10]; /* Déclaration d'un tableau de 10 nombres. */

int tab[5] ; Chaque élément est repéré par un indice
Les cases d'un tableau sont numérotées à partir de 0.
17
Pour plus de clarté, il est recommande de donner un nom à la constante (nombre-éléments)
par une directive au préprocesseur, par exemple #define
#define nombre-éléments 10
Le programme suivant imprime les éléments du tableau tab :
#define N 10
main()
{
int tab[N];
int i;
for (i = 0; i < N; i++)
printf("tab[%d] = %d\n", i, tab[i], tab[i] = i );
}
18
Notamment, un tableau ne peut pas figurer à gauche d’un opérateur d’affectation.
Par exemple, on ne peut pas écrire “tab1 = tab2;”.
Il faut effectuer l’affectation pour chacun des éléments du tableau :
#define N 10
main()
{
int tab1[N], tab2[N];
int i;
for (i = 0; i < N; i++)
tab1[i] = tab2[i];
}
19
Remarque :
✓ pas d'affectation entre tableaux : tab1 = tab2
provoque une erreur de compilation
✓ pas de comparaison de deux tableaux
20
On peut initialiser un tableau lors de sa déclaration par une liste de constantes de
la façon suivante :
type nom-du-tableau[N] = { val_1, val_2,...,val_N };
Par exemple, on peut écrire
#define N 4
int tab[N] = {10, 20, 30, 40};
main()
{
int i;
for (i = 0; i < N; i++)
printf("tab[%d] = %d\n", i, tab[i]);
}
21
De manière similaire, on peut déclarer un tableau à plusieurs dimensions.
Par exemple, pour un tableau à deux dimensions :

Type nom-du-tableau [nombre-lignes] [nombre-colonnes]
On accède à un élément du tableau par l’expression “tableau[i][j]”.

Exemple :
#define L 2
#define C 3
int tab[L][C] = {{1, 2, 3}, {4, 5, 6}};
main()
{
int i, j;
for (i = 0 ; i < L; i++)
{
for (j = 0; j < C; j++)
printf ("tab[%d][%d]=%d\n", i, j, tab[i][j]);
}
}

Il y a deux manières d’initialiser un tableau multi-dimensionnel :
float tab [ 3 ] [ 4 ] = { {0 ,1 ,2 ,3} , {4, 5, 6, 7 } , {8, 9, 10, 11 } };
float tab [ 3 ] [ 4 ] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 } ;
Elles sont complètement équivalentes.
24
DÉCLARATION D'UNE CHAÎNE DE CARACTÈRES
Une chaîne de caractères se déclare sous la forme d'un tableau de caractères de
longueur fixe.
Attention, comme signalé auparavant, ne dépassez pas la longueur du tableau.
Exemple : char ma_chaine [20] ;
permettra d'enregistrer des chaînes de 19 caractères maximum.
25
DÉCLARATION D'UNE CHAÎNE DE CARACTÈRES
tableau de caractères se termine par ' \0 ’ (backlash 0)
avec initialisation : char tab[8] = "hello !";

idem char tab[8] ={’h’, ’e’, ’l’, ’l’, ’o’, ’!’, ’\0’};
Pour lire une chaine de caractère

char ma_chaine[6] = "hello" ;
scanf( "%s", ma_chaine);
26
LES TABLEAUX : CHAÎNES DE CARACTÈRES
D'autre part, il est possible de déclarer une chaîne de caractères sans en spécifier
la longueur de départ de la façon suivante :
char chaine [ ] = "info" ; //on ne connaît sa taille que par son contenu
char tab[ ] = "exemple";

main()
{
int i;
printf("Nombre de caractères du tableau = %d\n", sizeof(tab));
}
27
LES TABLEAUX : CHAÎNES DE CARACTÈRES
un tableau de caractères peut être initialisé par une liste de caractères;
le compilateur complète toute chaıne de caractères avec un caractère nul ’\0’.
Il faut donc que le tableau ait au moins un élément de plus que le nombre de caractères de la
chaıne littérale.
#define N 8
char tab[N] = "exemple";
main()
{
int i;
for (i = 0; i < N; i++)
printf("tab[%d] = %c\n", i, tab[i]);
}

AFFICHAGE D'UNE CHAÎNE DE CARACTÈRES
Une chaîne de caractères s'affiche grâce à la commande printf et le format %s.
Exemple :
printf ("%s", chaine) ;
Longueur d'un chaîne

La longueur d'une chaîne de caractères s'obtient par la fonction strlen. Le 0 de fin
de chaîne n'est pas compté dans cette longueur.
Exemple :
char ch[ ] = "info" ;
printf ("La longueur de %s est : %d", ch, strlen (ch)) ;

ACCÈS AUX ÉLÉMENTS D’UN TABLEAU
On accède à un tableau en l'appelant par son nom et son numéro de case.
Exemple :
int tab_int[10]; /* tableau de 10 cases (0 à 9) d'entiers */
char tab_char[10]; /* tableau de 10 cases (0 à 9) de caractères */
tab_char [3] = 'C'; /* Accès à la case 3 (la quatrième) de tab_char */
tab_int [6] = 10; /* Accès à la case 6 (la septième) de tab_int */
30
ACCÈS AUX ÉLÉMENTS D’UN TABLEAU
31
INITIALISATIONS D’UN TABLEAU
32
LES STRUCTURES
Une structure contient une ou plusieurs variables groupées sous le même nom pour être traitées
comme une seule entité.
Contrairement aux variables stockées dans un tableau, les variables d’une structure peuvent être de
types différents.
Une structure peut contenir tous les types de données C, y compris les tableaux et les autres
structures.
les différents éléments d’une structure n’occupent pas nécessairement des zones contiguës en
mémoire.
Chaque élément de la structure, appelé membre ou champ, est désigné par un identificateur.

DÉCLARATION D’UNE STRUCTURES
La déclaration d’un modèle de structure dont l’identificateur
est Ident_struct suit la syntaxe suivante :
struct Ident_struct
{
type-1 champ-1;
type-2 champ-2;
...
type-n champ-n;
};
34
Note : Les types des champs d’une structure peuvent aussi être des types
composés, par exemple des tableaux ou des structures.
struct livre
Exemple : struct point
{
char titre[80]; {
char auteur[40]; char nom;
char editeur[40]; float x, y;
char ISBN10[11]; };
int nombre_pages;
int annee_edition;
double prix_chf;
} un_livre ;
35
Une fois le type de la structure déclarée, on peut utiliser son nom, précédé du mot
struct, comme tout autre type pour déclarer des variables :
struct Nom_du_type nom_de_la_variable;
Exemples :
struct Personne
{
char nom[40];
double taille;
int age;
char sexe;
};
struct Personne untel;
36
INITIALISATION D’UNE STRUCTURES
Exemple :
struct Patient
{
float taille;
int poids;
int age;
};
struct Patient p1 = { 180.75 , 73, 23 };
37
UTILISATION DE TYPEDEF
La façon la plus pratique de définir un type « structure » est sûrement d’utiliser conjointement typedef :
Exemples :
typedef struct Personne
{
char nom[ 40];
double taille;
int age;
char sexe;
} Personne untel;
Une structure définie de cette façon pourra alors être utilisée sans avoir besoin d’ajouter « struct »
avant : Personne untel;

UTILISATION DE TYPEDEF
Les structures peuvent être initialisées avec la syntaxe suivante :
Type identificateur = { val1, val2, ...};
où chaque vali est une valeur du type du champs correspondant.
Exemple :
typedef struct
{
char nom[40];
double taille;
int age;
char sexe;
} Personne;
Personne untel = {"Tal", 1.90, 18, 'M' };
39
L’ACCÈS AUX MEMBRES D’UNE STRUCTURE
On peut accéder aux champs d’une structure en utilisant la syntaxe suivante :
Syntaxe : nom_struct.nom_var
Exemples : Exemples :
Initialisation à la déclaration :
struct athlete
struct athlète A1={ "Bolt", "Usain", 23, 9.58};
{
char nom[30] ;
char prenom[30] ; accès aux champs par l’opérateur «.»
int dossard ; A1.temps = 9.54 ; A2.dossard = 2 ;
float temps ;
};
struct athlete A1, A2, A3 ; /* A1, A2, A3 sont des structures de type athlete */

EXEMPLE D’UNE STRUCTURES
Exemple :
#include <stdio.h>
#include <stdlib.h>
struct employe
{
char nom[30];
int empId;
float salaire;
};
int main()
{
struct employe emp1={ "Ali", 1120, 76909.00};
printf("nom: %s\n ", emp1.nom);
printf("Id: %d\n ", emp1.empId);
printf("Salaire: %f\n",emp1.salaire);
return 0;
} 41
EXEMPLE D’UNE STRUCTURES
#include <stdio.h>
typedef struct
{
char nom [40];
char prenom [20];
int age;
} personne;
int main ()
{
personne p;
printf("Veuillez entrer le nom de la personne :");
scanf("%s", p.nom);
printf("Veuillez entrer le prénom de la personne:");
scanf("%s", p.prenom);
printf("Veuillez entrer l’âge de la personne:");
scanf("%d", &p.age); /* ne pas oublier le & !!! */
printf("Voici les caractéristiques de cette personne:\n");
printf("nom=%s\n", p.nom);
printf("prénom=%s\n", p.prenom);
printf("âge=%d\n", p.age);
return 0;
}
42
LES POINTEURS
Lorsque l’on déclare une variable, par exemple un entier i,
l’ordinateur réserve un espace mémoire pour y stocker la valeur de i
L’emplacement de cet espace dans la mémoire est nommé adresse
Un pointeur est une variable qui permet de stocker une adresse
Par exemple si on déclare une variable entière i (initialisée a 10) et que l’on
déclare un pointeur p dans lequel on range l’adresse de i (on dit que p pointe
sur i), on a par exemple le schéma suivant :

POINTEUR VERS UN POINTEUR
Un pointeur se déclare en utilisant l’opérateur d’indirection (*). Ainsi :
int *ptr; //déclare un pointeur appelé ptr pouvant pointer vers une variable de type int
Vous pouvez utiliser l’opérateur d’adresse (&) pour placer dans ptr l’adresse d’une variable
particulière du type convenable (ici int) : ptr = &x;
Par cette instruction, vous rangez dans ptr l’adresse de la variable x. On dit alors que ptr pointe
vers x
Au moyen de l’opérateur d’indirection *, vous pouvez alors manipuler le

contenu de cette variable x
Les deux instructions suivantes donnent la valeur 12 à x :

x = 12;
*ptr = 12;
44
INTRODUCTION AUX POINTEURS
Int x;
Cette « déclaration de variable » réalise deux opérations :
Définition d’une variable x pouvant être utilisée dans le programme pour
manipuler des données.
Réservation ou allocation d’un espace mémoire où sera stocké le contenu de

la variable.
La variable x est stockée sur 4 octets. Son adresse est celle du 1er octet, soit
ici B01C.
45
La variable x a une adresse en mémoire(dans l’exemple précédent c’est B01C).
Pour avoir accès à l’adresse de la variable x, on utilise l’opérateur &.
&x représente l’adresse de la variable x.
Pour manipuler les adresses on définit un nouveau type de variable : les pointeurs
Un pointeur est une variable qui contient l’adresse d’une autre variable. C’est
une adresse typée.

On déclare une variable de type pointeur en préfixant le nom de la
variable par le caractère *
int i , j ;
int *p;
47
Opérateurs * et &
Il existe deux opérateurs permettant d’utiliser les pointeurs :
1) & : permet d’obtenir l’adresse d’une variable, permettant donc à un pointeur de
pointer sur une variable
2) * : permet de référencer un pointeur, c’est-à-dire d’accéder à la valeur de la
variable pointée
48
Opérateurs * et &
i = 10
P = &i; // p pointe sur i
*p = *p+2; // ajoute 2 a i
j = *p; // met la valeur de i dans j (donc 12)
49
Initialisation d’un pointeur

On peut donner l’adresse d’une variable déjà existante :
double y ;
double *p ;
p = &y ;
50
Pointer sur la case suivante :
p+1 pointe sur le double suivant en mémoire.
Contenu de la case mémoire suivante :

*(p+1) est le contenu de la variable pointée par p+1.
double y;
double *p;
p = &y;
La variable y est stockée sur 8 octets.

L’adresse de y est F01A. p vaut donc F01A.
51
52
INTRODUCTION AUX POINTEURS : VALEUR ET ADRESSE
main() main()
{ {
int i = 3, j = 6; int i = 3, j = 6;
int *p1, *p2; int *p1, *p2;
p1 = &i; p1 = &i;
p2 = &j; p2 = &j;
*p1 = *p2; p1 = p2;
}
}
après exécution
après exécution
53
Par défaut lorsque l’on déclare un pointeur, on ne sait pas sur quoi il pointe
Comme toute variable, il faut l’initialiser.
On peut dire qu’un pointeur ne pointe sur rien en lui affectant la valeur NULL
int i ;
int *p1, *p2;
p1=&i;
p2=NULL;
int *pentier = NULL;

double *pdouble = NULL;
printf ( "%x %x\n" , pentier +1, pdouble +1);
affichera :
0x4
0x8
54
POINTEUR VERS UN POINTEUR
Comme un pointeur est lui-même une variable numérique, il est situé dans la mémoire de
l’ordinateur à une adresse particulière.
Nous pouvons alors créer un pointeur vers un pointeur, c’est-à-dire une variable dont la valeur est
l’adresse d’un pointeur
int x = 12; /* x est une variable de type int */
int *ptr = &x; /* ptr est un pointeur vers x */
int **ptr_to_ptr = &ptr; /* ptr_to_ptr est un pointeur vers

un pointeur de type int */

TABLEAUX ET POINTEURS
Le nom d’un tableau vaut l’adresse de son 1er élément : a ≈ &a[0]
Donc, *(a+i) identique à a[i]
a+i identique à &a[i]
int a[5];
*a=7; /* affecte 7 à a[0] */
*(a+1)=2; /* idem a[1] = 2 */
int *pa = a; /* idem. pa = &a[0]; */
*(a+2)=12; /* idem. a[2]=12*/
56
TABLEAUX ET POINTEURS

LES POINTEURS DE FONCTION
En C (comme dans la plupart des autres langages), il n’est pas possible de placer le nom d’une
fonction dans une variable. En revanche, on peut y définir une variable destinée à pointer sur une
fonction, c’est-à-dire à contenir son adresse.
Exemple :
int (* adf) (double, int) ;
adf est un pointeur sur une fonction à deux arguments (double et int) retournant un résultat de type
int.
int fct(double, int) ;
adf = fct ; place, dans adf, l’adresse de la fonction correspondante fct
58
LES POINTEURS DE FONCTION
Exemple :
#include <stdio.h>
int carre(int a)
{
return a * a;
}
int main(void)
{
int (*pt)(int) = &carre;
printf("%d.\n", (*pt)(5));
return 0;
}
59
ALLOCATION DYNAMIQUE DE LA MÉMOIRE <STDLIB.H>
Allocation dynamique : La réservation de la mémoire pendant l'exécution du programme.
Exemple :
int *tab , n;
printf( "n=");
scanf( "%d", &n ) ;

tab = (int*) malloc (n∗ sizeof (int)) ;
60
ALLOCATION DYNAMIQUE DE LA MÉMOIRE <STDLIB.H>
Libération mémoire: Exemple
main()
{
int i = 3;
int *p;
p = (int *)malloc(sizeof(int));
*p=i;
printf("*p = %d \n",*p);
free(p);
printf("i = %d \n",i);
}
*p=3
i=3
61

SDD M3-Etd

Transféré par

Informations du document

Titre original

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

SDD M3-Etd

Transféré par

Droits d'auteur :

Formats disponibles

STRUCTURES DE DONNÉES

Dr MAHAMAT HABIB SENOUSSI HISSEIN

Ce nom est unique

Dr MAHAMAT HABIB SENOUSSI HISSEIN 2

type_retour nom_fonction (type_arg –1, ..., type_arg –n);

❑ Définition d’une fonction

double carré (double nombre) /* en-tête de fonction */

Dr MAHAMAT HABIB SENOUSSI HISSEIN 4

Dr MAHAMAT HABIB SENOUSSI HISSEIN 5

Dr MAHAMAT HABIB SENOUSSI HISSEIN 6

L’appel d’une fonction se fait par l’expression

Le corps de la fonction se termine par l’instruction de retour à la fonction appelante en utilisant le

Dr MAHAMAT HABIB SENOUSSI HISSEIN 7

int produit(int a, int b)

Dr MAHAMAT HABIB SENOUSSI HISSEIN 8

int add (int x, int y)

le module appelé de deux manières différentes :

double moyenne(int tab[ ], int taille)

nombre-éléments / taille du tableau : est une expression constante entière positive.

char tab_char [10]; /* Déclaration d'un tableau de 10 caractères */

int tab_int [10]; /* Déclaration d'un tableau de 10 nombres. */

Par exemple, on ne peut pas écrire “tab1 = tab2;”.

Il faut effectuer l’affectation pour chacun des éléments du tableau :

✓ pas d'affectation entre tableaux : tab1 = tab2

provoque une erreur de compilation

✓ pas de comparaison de deux tableaux

De manière similaire, on peut déclarer un tableau à plusieurs dimensions.

Par exemple, pour un tableau à deux dimensions :

Dr MAHAMAT HABIB SENOUSSI HISSEIN 22

Dr MAHAMAT HABIB SENOUSSI HISSEIN 23

avec initialisation : char tab[8] = "hello !";

Pour lire une chaine de caractère

char tab[ ] = "exemple";

Dr MAHAMAT HABIB SENOUSSI HISSEIN 28

Longueur d'un chaîne

Dr MAHAMAT HABIB SENOUSSI HISSEIN 29

int tab_int[10]; /* tableau de 10 cases (0 à 9) d'entiers */

char tab_char[10]; /* tableau de 10 cases (0 à 9) de caractères */

tab_char [3] = 'C'; /* Accès à la case 3 (la quatrième) de tab_char */

tab_int [6] = 10; /* Accès à la case 6 (la septième) de tab_int */

Dr MAHAMAT HABIB SENOUSSI HISSEIN 33

typedef struct Personne

Dr MAHAMAT HABIB SENOUSSI HISSEIN 38

int dossard ; A1.temps = 9.54 ; A2.dossard = 2 ;

Dr MAHAMAT HABIB SENOUSSI HISSEIN 40

Dr MAHAMAT HABIB SENOUSSI HISSEIN 43

Au moyen de l’opérateur d’indirection *, vous pouvez alors manipuler le

Les deux instructions suivantes donnent la valeur 12 à x :

Réservation ou allocation d’un espace mémoire où sera stocké le contenu de

Pour avoir accès à l’adresse de la variable x, on utilise l’opérateur &.

&x représente l’adresse de la variable x.

Dr MAHAMAT HABIB SENOUSSI HISSEIN 46

Il existe deux opérateurs permettant d’utiliser les pointeurs :

1) & : permet d’obtenir l’adresse d’une variable, permettant donc à un pointeur de

pointer sur une variable

2) * : permet de référencer un pointeur, c’est-à-dire d’accéder à la valeur de la

j = *p; // met la valeur de i dans j (donc 12)

Initialisation d’un pointeur

Contenu de la case mémoire suivante :

La variable y est stockée sur 8 octets.

int *pentier = NULL;

int x = 12; /* x est une variable de type int */

int *ptr = &x; /* ptr est un pointeur vers x */

int ptr = &x; / ptr est un pointeur vers x */