Point Eurs

Les pointeurs IFT-10541 Structures de donnes
!
Les pointeurs taient mis dans le mme sac que l'instruction goto comme une excellente technique de formuler des programmes incomprhensibles. Ceci est certainement vrai si les pointeurs sont employs ngligemment, et on peut facilement crer des pointeurs qui pointent 'n'importe o'. Avec une certaine discipline, les pointeurs peuvent aussi tre utiliss pour programmer de faon claire et simple. C'est prcisment cet aspect que nous voulons faire ressortir dans la suite.
Cette constatation a ensuite motiv les crateurs du standard ANSI-C prescrire des rgles explicites pour la manipulation des pointeurs.
Abder Alikacem
Dpartement dinformatique et de gnie logiciel
Les pointeurs Semaine 2 Les pointeurs

Dfinition du type pointeur Arithmtique des pointeurs Application des pointeurs Prlude la gestion dynamique de la mmoire Lide de pointeur sapparente celle d'indice dans un tableau. X[6] indique le 7e lment du vecteur X. Le 6 indique la position dans le tableau o se trouve une valeur donne. On se sert donc de la constante 6 pour pointer sur l'lment voulu du vecteur X.
0 1 2 3 4 5 6 7 8 9
14 5 47 8
4 16 3 87 2 26
Les pointeurs
Dfinition
Un pointeur est une variable contenant ladresse dune donne (dans le vocabulaire du langage C, le procd qui consiste atteindre une donne via un pointeur sur cette donne sappelle une indirection).
Les pointeurs : le type

Dfinition en termes de type abstrait:
le rle d'un pointeur est de permettre l'accs une structure qui serait cre avant ou lors de l'excution. la dclaration doit spcifier le type de base de l'objet qui pourra tre accessible l'aide du pointeur.

Toujours une valeur absolue Adresses admissibles = entiers de longueur fixe (uniformit => rfrence uniforme et homogne) Code de format %p (criture en hexadcimale) Le type pointeur est considr comme tant un type de base.
(manipulations)
associer un pointeur un objet (de type de base) qui sera accessible l'aide de ce pointeur (ceci ne dfinit pas pour autant la valeur qui sera associe l'objet), dtruire l'objet accessible l'aide du pointeur indiquer l'absence d'objet accder, permettre un pointeur d'accder au mme objet qu'un autre pointeur, associer une valeur de type de base l'objet accessible par un pointeur, fournir la valeur de type de base associe l'objet accessible par un pointeur (diagnostiquer le cas o il n'y a pas d'objet accder), comparer deux pointeurs de mme type de base pour savoir s'ils permettent d'accder au mme objet.
Oprateurs dadressage
adresse = information que lon peut
char *ptC; float *ptT; int *ptP;
Loprateur * dsigne le contenu de la variable dont ladresse est loprande. Par exemple, *ptr retourne le contenu de la variable dont ladresse est ptr.
*pointeur : rfre la variable pointe (oprateur d'indirection) Notez que dans une dclaration, loprateur * na pas le mme sens. Par exemple, la dclaration int* n; signifie que n est un pointeur sur un entier.
stocker dans une variable pointeur
Les oprateurs sont utilises avec des pointeurs.
Les pointeurs et le C
Exemple 1 int i1=1,i2=2; int *p1,*p2; p1=&i1; p2=p1; printf("%d\n",*p1) p2=&i2; *p2=*p1; printf("%d\n",i2)
L'oprateur &
&variable : donne l'adresse d'une variable dans un scanf partout dans un programme Si une adresse est mise dans une autre variable, cette autre variable doit tre un pointeur.
/*affiche ?*/ /*affiche ?*/
Exemple 2 #include<stdio.h> int main() { int i; int * j; i = 1; j = &i; *j = 2; printf("i vaut : %dn", i); } return 0;
Exemple 4 int main() { int i; int *ptrI; ptrI = &i; printf("La valeur pointe par ptrI est %d\n", *ptrI); return(0); }
Exemple 3 int main() { int i; int *ptrI; ptrI = &i; printf("La valeur pointe par ptrI est %d\n", ptrI); return(0); }
Exemple 5 int main() { int i; int *ptrI; ptrI = &i; i = 15; printf("La valeur pointe par ptrI est %d\n", *ptrI); return(0); }
Quelques lments de syntaxe

Exemple 6 int* ad1, * ad2, * ad; int n = 10, p = 20; ad1 = &n; ad2 = &p; *ad1 = *ad2 + 2; (*ad1)++; ad++; ad += 10; ad -= 25; n= ad1-ad2;

Remarque 2 Une dclaration telle que : int* ad;
/*identique n=p+2; */ /* identique n++;*/
rserve un emplacement en mmoire pour un pointeur sur un entier elle ne rserve pas en plus un emplacement pour un entier.

Remarque1 Si ad est un pointeur, ad et *ad sont des lvalue: ils sont modifiables. Il n'en va pas de mme de &ad : (&ad)++; sera rejete la compilation.
Mmoire principal
pointeur = adresse en mmoire
0: 4: 8: 12: 16: 1020: 1: 5: 9: 13: 17: 1021: 2: 6: 10: 14: 18: 1022: 3: 7: 11: 15: 19: 1023:
32 bits
Mmoire principal
Dclarations:
char c; float t; int p;
0: 4: 8: 12: 16: 1: 5: 9: 13: 17: 1021: 2: 6: 10: 14: 18: 1022: 3: 7: 11: 15: 19: 1023:
Oprateur dindirection
affectations: ptP = &p; *ptP = 3;
char c; float t; int p; int *ptP;
0 : 0: 4 : 4: 8: 1: 5: 9: 13: 17: 1021: 2: 6: 10:
(p = 3;) (*&p = 3;)

3: 7: 11: 15: 19: 1023:
12: 12:
31 4 : 12
18: 1022:
rservation de lespace (~longueur) association: nom adresse convention de reprsentation alignement
1020:
int * ptP ; int * ptP ;
16: 16: 1020:
Variable pointeur: dclaration

Dclarations:
0: 4: 8: 12: 1: 5: 9: 13: 17: 1021: 2: 6: 10: 14: 18: 1022: 3: 7: 11: 15: 19: 1023:
Variable pointeur: affectation

affectations: ptP = &p; *ptP = 3;
(p = 3;) (*&p = 3;)
0 : 0: 4 : 4: 8:
1: 5: 9: 13: 17: 1021:
2: 6: 10:
3: 7: 11: 15: 19: 1023:
12: 12:
31 4 : 121 8 :
1022:
16: 1020:
16: 16: 1020:
Reprsentation graphique
affectations:
affectations:
ptP = &p; *ptP = 3;
ptP = &p; *ptP = 3;
ptP
ptP
p 3
affectations:
Pointeur sur variable pointeur

Dclarations:
char c; float t; int p; int *ptP; int **ptPtP; int **ptPtP ; int * *ptPtP ; int ** ptPtP ;
0: 4: 8: 12: 16: 20: 1020: 1: 5: 9: 13: 17: 1021: 2: 6: 10: 14: 18: 1022: 3: 7: 11: 15: 19: 1023:
ptP = &p; *ptP = 3;
ptP
Variable pointeur: affectations

affectations:
char c; float t; int p; int *ptP; int **ptPtP; int **ptPtP ; int * *ptPtP ; int ** ptPtP ; ptPtP = &ptP;
0 : 0: 4 : 4: 8: 1: 5: 9: 13: 17: 1021: 2: 6: 10: 3: 7: 11: 15: 19: 1023:
affectations:
ptPtP = &ptP;
ptPtP
ptP
p 3
12: 12:
16: 16: 20: 1020:
14:
121 8 : 16
1022:
Variable pointeur: affectations

affectations:
char c; float t; int p; int *ptP; int **ptPtP; int **ptPtP ; int * *ptPtP ; int ** ptPtP ; ptPtP = &ptP; **ptPtP = 4;
0 : 0: 4 : 4: 8: 1: 5: 9: 13: 17: 1021: 2: 6: 10: : x1 44 3 3: 7: 11: 15: 19: 1023:
affectations:
ptPtP = &ptP;
ptPtP
ptP
p 3
12: 12:
16: 16: 20: 1020:
12 16
18:
1022:
affectations:
affectations:

ptPtP = &ptP; **ptPtP = 4;
#include <stdio.h> *ptPtP = NULL; /* utile pour tester */ if (*ptPtP == NULL)

(p est toujours accessible par son nom!!)
ptPtP
ptP
p 3 x4
ptPtP
ptP
p 4
Pointeur NULL
affectations:

Pointeur NULL: affectation

affectations:

#include <stdio.h> *ptPtP = NULL; /* utile pour tester */
#include <stdio.h> *ptPtP = NULL; ptPtP = NULL;

(et non linverse!!!)
ptPtP
ptP X
p 4
ptPtP X
ptP
p 4
affectations:

Utilit des pointeurs

utiliser une variable sans connatre son nom

#include <stdio.h> *ptPtP = NULL; ptPtP = NULL; if (ptPtP == NULL) ...
(*ptP)++ ((*ptP)+1)/4 printf(%d,*ptP) scanf(%d,ptP)
p++ (p+1)/4 printf (%d, p) scanf(%d,&p)
ptPtP
ptP
p 4
Affectations de pointeurs
On peut affecter un pointeur une variable pointeur de mme type. Sauf:


si lon procde par conversion explicite

pt1 = (char *) pt2; /* avec: char * pt1; int *pt2; */ pt1 = (float *) pt2; /* avec: float * pt1; int *pt2; */
si on affecte l entier 0
pt1 = 0; /* dconseiller: utilisez NULL plutt */
fonctions plusieurs arguments de sortie
ou un pointeur de type gnrique void *

pt1 = (char *) pt2;
/* avec: char * pt1; void * pt2;*/
pt3 = pt1; /* avec: void * pt3; */ pt2 = (int *) pt3; pt2 = (char *) pt3; printf("La valeur pointe par pt1 est %c\n", *(char*)pt2);
10


Plus dun argument de sortie

changer le contenu de 2 variables:

version 1 version 2
fonctions plusieurs arguments de sortie calcul dadresse
retourner un code derreur

Li L L +i x
int elementListe(Liste l, int pos, int *err); Liste ajouterListe(Liste l, int x, int pos, int *err);


Calcul dadresses
1 tableau = une suite de cases, qui

qui sont contigus peuvent tre accdes partir dune adresse de base, par un dplacement (indice) ex: char tab[8];
fonctions plusieurs arguments de sortie calcul dadresse allocation dynamique de mmoire

b o n j o u r \0
0 1 2 3 4 5 6 7
11
Calcul dadresses
nom du tableau =

Calcul dadresses
int note[4]={56, 23,67,89}; int *liste; note[i] = *(note+i) = *(note+(i* "sizeof(int)" ); liste=note; liste[i] = *(liste+i) = *(liste+(i* "sizeof(int)" ); printf("%d", *++liste); printf("%d", ++*liste); printf("%d", *liste++);
note liste
adresse de dpart pointeur sur un char

char tab[8] = bonjour; char *chaine; chaine = tab; /* tab est une valeur constante! */
tab chane
b o n j o u r \0
0 1 2 3 4 5 6 7 0 1 2 3
Calcul dadresses
tab[0] = *tab = *chaine tab[i] = *(tab+i) = *(chaine+i) &tab[0] = &(*(tab+0)) = &*tab = tab i = dplacement en nb dlments tab[i] = *(tab+(i* "sizeof(char)" )
tab chane
Calcul dadresses
&tab[i] = &(*(tab+i)) = tab+i &tab[7]-tab = tab+7-tab = 7 (lments) &note[3]-&note[0] = &(*(note+3))-note = 3
note
0 1 2 3
tab
1 2 3 4 5 6 7
b o n j o u r \0
0
chane
b o n j o u r \0
0 1 2 3 4 5 6 7
12
Exemple: strlen
strlenV1: utilisant un tableau strlenV2: utilisant un pointeur strlenV3: calcul dadresse appel: strlen(tab), strlen(bonjour), strlen(chaine) autres appels: strlen(&tab[3]), strlen(&chaine[4])
tab chane
Calcul dadresses
char *tab[ ] = { "Eleves","Prof","Stage"}; tab : est quivalent : &tab[0] : c'est l'adresse du premier lment du tableau. *tab : est quivalent : tab[0] : c'est le premier lment du tableau, c'est dire l'adresse du premier caractre de la chane "Eleves". tab[1] : est l'adresse sur le premier caractre de la chane "Prof".
b o n j o u r \0
0 1 2 3 4 5 6 7
*(tab+1) : est quivalent : tab[1]
Calcul dadresses
soit un tableau de chanes de caractres : char tab[10][81]; (rserve 810 octets) on pourrait dfinir un tableau de pointeurs sur des chanes : char *tab[10]; (rserve 10 var. pointeur) avantage :

Calcul dadresses
char *tab[ ] = { "Eleves","Prof","Stage"}; *tab[1] : est le caractre point par tab[1] : c'est le caractre 'P' de la chane "Prof". **tab : est quivalent : *tab[0] :c'est le caractre 'E' de la chane"Eleves". **(tab+1) : est quivalent : *tab[1] :c'est le caractre 'P' de la chane"Prof". *(tab[2]+1) : est quivalent : tab[2][1] :c'est le caractre 't' de la chane"Stages".
longueur variable (adapte) occupe moins de mmoire que la place ncessaire!!!!
voir un exemple dans Main.doc (Code source

des exemples de la semaine)
13
Utilisation des pointeurs

Pointeurs sur structures Exemple #include <stdio.h> typedef struct { float x; float y; } Point;
Pointeur sur une fonction

int tab[10];
tab est l'adresse du premier octet du tableau. fonctionQc est l'adresse du premier octet implantant la fonction.
void fonctionQc(int i, int j){}

Pointeurs sur structures int main (void) { Point sommetA; Point* ptr; ptr = &sommetA; /* premier type d'accs, classique */ (*ptr).x = 3.33; /* deuxime type d'accs, nouveau */ ptr->y = 2.22; printf("%f, %f", ptr->x, (*ptr).y); return 0; }
Pointeur sur une fonction

Pour dclarer une variable de type pointeur sur une fonction :
void (*f)(int, int);
la dclaration, il faut dfinir :

le type des paramtres le type de retour
14
Exemple 1
int addition(int i, int j); int main() { int (*fonction)(int, int); /*dclaration d'un pointeur sur une fonction*/ int i=1, j=2, k; /*dclaration de 3 entiers*/ fonction = addition; k k k k } = = = = fonction(i,j); (*fonction)(i,j); addition(i,j); (*addition)(i,j);
Exemple 3
Exemple 3 : un pointeur sur une fonction comme paramtre d'une 2me fonction
void tri(int *tab, int size, Bool (*compare)(int, int)) { int idx, count; void swap(int *, int *); for (idx = 1; idx <= size - 1; idx++) for (count = 0; count <= size - 2; count++) if ((*compare)(tab[count], tab[count + 1])) swap(&tab[count], &tab[count + 1]); }
return(0);
L'ordre du tri est dfini par la fonction compare
Exemple 2
int addition(int i, int j) { return i+j; } int main() { int (*fonction)(int, int); /*dclaration d'un pointeur sur une fonction*/ int i=1, j=2, k; /*dclaration de 3 entiers*/ fonction = addition; printf("%p\n", addition); printf("%p\n", fonction); return(0); }
Exemple 4
int int int int
une calculette
Un tableau de pointeurs sur des fonctions

addition(int n1, int n2) { return n1 + n2; } soustraction(int n1, int n2) { return n1 - n2;} multiplication(int n1, int n2) { return n1 * n2;} division(int n1, int n2) {return n1 / n2; }
int main() { int i, j ,k; int (*ptf[ ])(int , int) = {addition, soustraction, multiplication, division}; k = ptf[0](i, j); k = (*ptf[0])(i, j);
15
Exemple 4suite
char operation, tabop[]="+-*/"; int nbre1, nbre2, i;
Exemple 4..suite
printf("%d %c %d = %d\n", nbre1, operation, nbre2, (*ptf[i])(nbre1, nbre2) ); /* deuxime possibilit d'appel indirect */ printf("%d %c %d = %d\n", nbre1, operation, nbre2, ptf[i](nbre1, nbre2) ); } return 0;
Exemple 4suite
printf("Nombre 1 : "); scanf("%d", &nbre1); fflush(stdin); printf("Nombre 2 : "); scanf("%d", &nbre2); fflush(stdin); do { printf("opration (+ , -, * ou /) : "); scanf("%c", &operation); fflush(stdin); for (i = 0; i < 4; i++) if (tabop[i] = = operation) break; } while ( i = = 4 );
Type Rcursif
On dsire reprsenter un arbre gnalogique. Chaque personne est caractrise par son nom, son prnom, son pre et sa mre. Les parents d'une personne sont aussi des personnes. On aimerait donc pouvoir disposer du nouveau type personne suivant : struct pers { char nom[20]; char prenom[20]; struct pers pere; struct pers mere; }; struct pers moi;
16
Type Rcursif
Donc il faudrait rserver une place mmoire infinie. Comment s'en sortir ? Une fois de plus... grce aux pointeurs : struct pers { char nom[20]; char prenom[20]; struct pers* pere; struct pers* mere; }; struct pers moi;

Allocation dynamique de la mmoire
Obtenir des variables (de la mmoire)

selon les besoins de lapplication gestion dynamique de la mmoire mais: variables sans noms! => accs par pointeur
debut
Type Rcursif
Pourquoi cette version-l est-elle correcte ? Comme cela a dj t dit, lorsque l'on dclare une variable de type pointeur sur quelque chose, seule la place ncessaire au stockage du pointeur est rserve. Et celle-ci est fixe (4 octets en gnral). Donc, le compilateur peut rserver pour moi une place de 20+20+4+4=48 octets. Le code suivant permet alors de donner moi des parents : struct pers monPere; struct pers maMere; moi.pere = &monPere; moi.mere = &maMere;
Structures pointes
typedef struct element { TypeEl el; /* linformation stocker */ struct element *suivant; } elem; elem *debut, *courant, *nouveau; elem t1, t2, t3; debut = &t1;
debut el el
courant el
suivant t1
suivant t2
suivant t3
17
Accs aux structures pointes

t1.el = 3; ou (*debut).el = 3; ou debut->el = 3;

t1.el = 3; ou (*debut).el = 3; ou debut->el = 3; t1.suivant = NULL; ou (*debut).suivant = NULL ou debut->suivant = NULL; t1.suivant = &t2; ou (*debut).suivant = &t2 ou debut->suivant = &t2;
courant debut el el el
3
suivant t1 suivant t2 suivant t3
3

t1.el = 3; ou (*debut).el = 3; ou debut->el = 3; t1.suivant = NULL; ou (*debut).suivant = NULL ou debut->suivant = NULL;

t1.el = 3; ou (*debut).el = 3; ou debut->el = 3; t1.suivant = NULL; ou (*debut).suivant = NULL ou debut->suivant = NULL; t1.suivant = &t2; ou (*debut).suivant = &t2 ou debut->suivant = &t2; debut->suivant->el = 4;
3
3
suivant t1
4
suivant t2 suivant t3
18

t1.el = 3; ou (*debut).el = 3; ou debut->el = 3; t1.suivant = NULL; ou (*debut).suivant = NULL ou debut->suivant = NULL; t1.suivant = &t2; ou (*debut).suivant = &t2 ou debut->suivant = &t2; debut->suivant->el = 4; debut->suivant->suivant = NULL; courant
debut el el el

courant = debut->suivant; (*courant).el = 4; ou courant->el = 4;
3
suivant t1
4
3
suivant t1
4

courant = debut->suivant;

courant = debut->suivant; (*courant).el = 4; ou courant->el = 4; (*courant).suivant = NULL; ou courant->suivant = NULL;
courant debut el el el debut el el
courant el
3
3
suivant t1
4
19

courant = debut->suivant; (*courant).el = 4; ou courant->el = 4; (*courant).suivant = NULL; ou courant->suivant = NULL; courant->suivant = &t3;

courant = debut->suivant; (*courant).el = ...; ou courant->el = ...; (*courant).suivant = NULL; ou courant->suivant = NULL; courant->suivant = ...; courant = courant->suivant;
3
suivant t1
4
3
suivant t1
4
suivant t2
...
suivant t3

courant = debut->suivant; (*courant).el = 4; ou courant->el = 4; (*courant).suivant = NULL; ou courant->suivant = NULL; courant->suivant = &t3; courant = courant->suivant;

3
suivant t1
4
3
suivant t1
4
suivant t2
...
suivant t3
20

courant
Allocation de mmoire
obtenir les structures au besoin:
debut = (elem *)malloc(sizeof(elem));

rserve de lespace sur le heap (tas) retourne un pointeur sur une struct element retourne NULL si plus de mmoire
debut debut el el el
el
3
suivant t1
4
suivant t2
...
suivant suivant t3 pile tas

courant

debut debut el el el
el
3
suivant t1
4
suivant t2
...
suivant suivant t3 pile tas
21


if (debut != NULL) {debut->el = 3; debut->suivant = NULL;}
debut
el
if (debut != NULL) {debut->el = 3; debut->suivant = NULL; }
debut
el
3
suivant pile tas
suivant pile tas
Libration de mmoire


if (debut != NULL) {debut->el = 3; debut->suivant = NULL;}
debut
el
if (debut != NULL) {debut->el = 3; debut->suivant = NULL;} free(debut); debut = NULL; /* et non linverse */
debut
el
3
suivant pile tas
suivant pile tas
22
Libration de mmoire
Libration de mmoire


debut
el
suivant pile tas
x
3
if (debut != NULL) {debut->el = 3; debut->suivant = NULL;} debut = NULL; free(debut); /* Ne pas faire */
debut
el
3
suivant pile tas
Libration de mmoire
Chanage de structures
debut = (elem *)malloc(sizeof(elem)); if (debut != NULL) {debut->el = 3; debut->suivant = NULL;} debut = (elem *)malloc(sizeof(elem));
el

debut
suivant pile tas
x
3
debut
el
3
suivant pile tas
23
debut = (elem *)malloc(sizeof(elem)); if (debut != NULL) {debut->el = 3; debut->suivant = NULL;} debut = (elem *)malloc(sizeof(elem));
debut
/* pour le premier lment */ debut = (elem *)malloc(sizeof(elem)); if (debut != NULL) { debut->el = 3; debut->suivant = NULL;} else ... courant = debut;
el
nouveau courant el
suivant el
3
suivant pile tas
/* pour les autres lments */ nouveau = (elem *)malloc(sizeof(elem)); debut if (nouveau != NULL) { nouveau->el = ...; nouveau->suivant = NULL;} else ... pile courant->suivant = nouveau; courant = nouveau;
suivant tas
nouveau courant
nouveau courant el
tas
3
suivant tas
24
/* pour le premier lment */ debut = (elem *)malloc(sizeof(elem)); if (debut != NULL) { debut->el = 3; debut->suivant = NULL; } else ... courant = debut;
el
nouveau courant
nouveau courant
el
3
suivant tas
suivant el
3
suivant tas
el
nouveau courant
nouveau courant
el
...
suivant el
3
suivant tas
3
suivant tas
25
nouveau courant
el
nouveau courant
el
...
suivant el
...
suivant el
/* pour les autres lments */ nouveau = (elem *)malloc(sizeof(elem)); debut if (nouveau != NULL) { nouveau->el = ...; nouveau->suivant = NULL; } else ... pile courant->suivant = nouveau; courant = nouveau;
3
suivant tas
3
suivant tas
nouveau courant
el
nouveau courant
el
...
suivant el
...
suivant el
3
suivant tas
/* pour les autres lments */ nouveau = (elem *)malloc(sizeof(elem)); debut if (nouveau != NULL) { nouveau->el = ...; nouveau->suivant = NULL;} else pile courant->suivant = nouveau; courant = nouveau;
3
suivant tas
26
el suivant el
el
...
nouveau courant suivant el
nouveau courant
...
suivant el
...
suivant el
3
suivant tas
/* pour les autres lments */ nouveau = (elem *)malloc(sizeof(elem)); debut if (nouveau != NULL) { nouveau->el = ...; nouveau->suivant = NULL; } else pile courant->suivant = nouveau; courant = nouveau;
3
suivant tas
el
...
suivant el
nouveau courant
...
suivant el
el
...
nouveau courant suivant el
...
suivant el
3
suivant tas
3
suivant tas
27
el
...
suivant el
nouveau courant
/* pour le premier lment */ debut = new(3,&err); if (err != 0) exit(1); courant = debut;
nouveau courant
...
suivant el
3
suivant tas
/* pour les autres lments */ nouveau = new(,&err); if (err != 0) exit(1); courant->suivant = nouveau; courant = nouveau;
debut
pile
tas
/* pour le premier lment */ debut = (elem *)malloc(sizeof(elem)); if (debut != NULL) { debut->el = 3; debut->suivant = NULL;} else ... courant = debut; /* pour les autres lments */ nouveau = (elem *)malloc(sizeof(elem)); if (nouveau != NULL) { nouveau->el = ...; nouveau->suivant = NULL;} else courant->suivant = nouveau; courant = nouveau;
nouveau courant
fonction new
debut el
3
suivant pile tas
28
nouveau courant
nouveau courant
el
...
suivant el
debut
el
3
suivant pile tas
debut
3
suivant pile tas
nouveau courant
el
nouveau courant
el
...
suivant el
...
suivant el
debut
3
suivant pile tas
debut
3
suivant pile tas
29
nouveau courant
el
...
suivant el
debut
3
suivant pile tas
Remarques
Attention aux ordures! Attention aux rfrences pendantes!
30

Point Eurs

Hochgeladen von

Dokumentinformationen

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

Point Eurs

Hochgeladen von

Copyright:

Verfügbare Formate

Les pointeurs IFT-10541 Structures de donnes

Les pointeurs Semaine 2 Les pointeurs

Les pointeurs : le type

Les pointeurs : le type

Les pointeurs : le type

stocker dans une variable pointeur

/*affiche ?*/ /*affiche ?*/

Quelques lments de syntaxe

Quelques lments de syntaxe

/*identique n=p+2; */ /* identique n++;*/

Quelques lments de syntaxe

(p = 3;) (*&p = 3;)

rservation de lespace (~longueur) association: nom adresse convention de reprsentation alignement

int * ptP ; int * ptP ;

16: 16: 1020:

Variable pointeur: dclaration

Variable pointeur: affectation

1: 5: 9: 13: 17: 1021:

3: 7: 11: 15: 19: 1023:

int * ptP ; int * ptP ;

int * ptP ; int * ptP ;

16: 16: 1020:

ptP = &p; *ptP = 3;

ptP = &p; *ptP = 3;

Pointeur sur variable pointeur

ptP = &p; *ptP = 3;

Variable pointeur: affectations

Variable pointeur: affectations

ptPtP = &ptP; **ptPtP = 4;

#include <stdio.h> *ptPtP = NULL; /* utile pour tester */ if (*ptPtP == NULL)

Pointeur NULL: affectation

#include <stdio.h> *ptPtP = NULL; /* utile pour tester */

#include <stdio.h> *ptPtP = NULL; ptPtP = NULL;

Utilit des pointeurs

#include <stdio.h> *ptPtP = NULL; ptPtP = NULL; if (ptPtP == NULL) ...

(*ptP)++ ((*ptP)+1)/4 printf(%d,*ptP) scanf(%d,ptP)

p++ (p+1)/4 printf (%d, p) scanf(%d,&p)

Utilit des pointeurs

si lon procde par conversion explicite

(*ptP)++ ((*ptP)+1)/4 printf(%d,*ptP) scanf(%d,ptP)

p++ (p+1)/4 printf (%d, p) scanf(%d,&p)

fonctions plusieurs arguments de sortie

ou un pointeur de type gnrique void *

/* avec: char * pt1; void * pt2;*/

Utilit des pointeurs

Plus dun argument de sortie

(*ptP)++ ((*ptP)+1)/4 printf(%d,*ptP) scanf(%d,ptP)

p++ (p+1)/4 printf (%d, p) scanf(%d,&p)

fonctions plusieurs arguments de sortie calcul dadresse

retourner un code derreur

Utilit des pointeurs

(*ptP)++ ((*ptP)+1)/4 printf(%d,*ptP) scanf(%d,ptP)

p++ (p+1)/4 printf (%d, p) scanf(%d,&p)

fonctions plusieurs arguments de sortie calcul dadresse allocation dynamique de mmoire

adresse de dpart pointeur sur un char

*(tab+1) : est quivalent : tab[1]

longueur variable (adapte) occupe moins de mmoire que la place ncessaire!!!!

voir un exemple dans Main.doc (Code source

Utilisation des pointeurs

Pointeur sur une fonction

void fonctionQc(int i, int j){}

Utilisation des pointeurs

Pointeur sur une fonction

void (*f)(int, int);

/affiche ?/ /affiche ?/

/identique n=p+2; / /* identique n++;*/

#include <stdio.h> ptPtP = NULL; / utile pour tester / if (ptPtP == NULL)

#include <stdio.h> ptPtP = NULL; / utile pour tester */

(ptP)++ ((ptP)+1)/4 printf(%d,*ptP) scanf(%d,ptP)

(ptP)++ ((ptP)+1)/4 printf(%d,*ptP) scanf(%d,ptP)

(ptP)++ ((ptP)+1)/4 printf(%d,*ptP) scanf(%d,ptP)

(ptP)++ ((ptP)+1)/4 printf(%d,*ptP) scanf(%d,ptP)