Les pointeur et les listes dynamique
I les pointeurs:1- Définition
Un pointeur est une variable qui garde l'adresse mémoire d'une autre variable.
L'adresse mémoire est une donnée numérique(entier), le type d'un pointeur est le même que le type de la variable. Deux Opérateur permettent de manipuler l'adresse mémoire et le contenu d'un espace mémoire et qui sont:
En algo:
En C:
adresse(variable)
&variable
contenu(pointeur)
*pointeur
Declaration:
Algo:
C:
Nompointeur: pointeurde type
Type * nom_pointeur
Exemple ilustration:
int x = 15;
int *ptr = &x
exemple 2:
printf(''Valeur de x : %d '',x);
printf('' valeur de x : %u'',&x);
printf(''valeur de x: %d'', *ptr);
printf(''valeur de x: %u'',ptr);
Un pointeur c'est quoi?
C'est l'adresse d'une variable.
2) allocation et liberation de mémoire:
On peut allouer puis liberer de l'espace mémoire à un pointeur qui n'a pas eu d'affectation d'adresse d'une variable exitante.
Algo C
nom_pointeur <--- allouer(taille(type)) nompointeur=(type *)malloc(sizeof(type));
liberer(nom_pointeur) free(nompointeur);
exemple:
int * ptr;
ptr=(int *)malloc(sizeof(int));
//allocation d'un espace mémoire la taille est celle qu'occupe une variable de type entier
* ptr = 15;
le contenu de l'espace mémoire
pointé par PTR recoive la valeur 15
printf(''valeur pointée : %d'',*ptr);
free(ptr);
3) Les pointeurs et les tableaux:
En C, le nom d'un tableau est considérer comme un pointeur gardant l'adresse du 1er élément du tableau appelé adresse de base du tableau.
Exemple:
int tab[10];
0 10
tab est un pointeur qui garde l'adresse de tab[0] première élément
Puisque les éléments d'un tableau occupent des espace mémoire contigues , on peut utiliser des pointeurs pour parcourir un tableau.
Utilisation de la notion d'indice et de la notion de pointeur pour parcourir un tableau
Notion d'indice
Notion d'adresse
Int tab[0];
int i;
//saisi
for(i=0,i<10;i++)
{
printf(''Element: %d'',i+1);
scanf(''%d'',&tab[i]);
}
//affichage
for(i=0;i<10;i++)
{
printf(''element: %d=%d'',i+1,tab[i]);
}
Int tab[0];
int * ptr;
//saisi
for(ptr = tab ; ptr < tab+10; ptr++)
{
printf(''Element : %d '' , ptr + 1 – tab);
scanf(''%d'',ptr);
}
//affichage
for(ptr = tab ; ptr < tab+10 ; ptr++)
{
printf(''Element : %d = %d'',ptr+1 – tab,*ptr);
}
4)Les pointeurs et les chaines de caractère:
Une chaine de caractère est considérer en C, comme un tableau terminée par le caratère « \0 » donc elle aussi est manipulé comme un pointeur.
Exemple:
char tab[]= ''limoge'';
char * ptr;
ptr = tab;
L
I
M
O
G
E
S
\0
Instruction Affichage
printf(''%s'',tab); limoges
printf(''%s'',ptr); limoges
printf(''%c'',*ptr); l
printf(''%c'',*(ptr+2)); m
ptr+ = 3;
printf(''%c'',*ptr); o
printf(''%s'',ptr); oges
printf(''%c'',tab[ptr-tab+1]); g
ptr -= 1;
printf(''%s'',ptr); moges
printf(''%s'',(ptr+2)); ges
printf(''%c'',*(ptr+2)); g
5) les tableaux dynamiques:
les tableaux dynamiques sont des tableaux dont la taille, est fixé pendant l'exécution avec des allocations dynamique dans la mémoire
exemple:
déclaration et allocation
int * tab;
int nb;
printf(« rentrer un nombre d'élément: »);
scanf(''%d'',&nb);
tab=(int )malloc(sizeof(int)*nb);
tab : est un pointeur qui garde l'adresse du 1er d'un tableau de nb élément.
Les tableaux dynamique se gérent comme les tableaux statiques: affichage, saisie, parcour,...
s'il y a lieu de changer de taille, on doit libérer l'espace alloué, puis réallouer l'espace souhaité.
6) Passage de paramètres:
Le passage de paramètre entre les procédures peut se faire de deux manière:
- Passage pour valeur:
la procédure prend une copie du paramètre et ne répresente aucune modification sur le paramètre recu.
-Passage par adresse :
La procédure recoit l'adresse du paramètre et donc elle travaille directement sur la valeur du paramètre, les modifications apportés au paramètre seront effectives.
En C , le passage par adresse utilise la notion de Pointeur.
Passage par valeur:
void ajout(int x)
{
n = x + 5 ;
}
int main(void){
int a = 15;
ajoute(a);
printf(''A vaut : %d '',a); => a = 15;
return 0;
}
Passage en utilisant le retour Fonction:
a=> 20
Passage par adresse:
void ajout ( int * x)
{
* x = * x + 5;
}
int main()
{
int a = 15;
ajout ( &a ) ;
printf('' a vaut : %d'', a );
return 0;
}
|
Programmation 