je vais vulgariser et simplifier.
En fait c´est pas compliqué:
Lorsqu´une variable est créé normalement(on va oublier new et delete pour l´instant) l´OS va trouver un endroit vide dans la mémoire de la taille de la variable ( avec sizeof() ) .L´endroit ou est est placé est représenté avec un nombre(appelée adresse, et valant quatre octets). Lorsque on incrémente un variable par exemple, on va à l´adresse de cette variable, et on incrémente le nombre à cette adresse ( ce nombre est en fait là valeur de la variable).
Un moyen simple de comprendre ça sont des classeurs. Dans chaque classeur il y a un chiffre. Losqu´on fait quelque chose à se chiffre, comme faire +3, on trouve le numéro de classeur, on l´ouvre, on prend le chiffre, on lui rajoute plus 3, on le remet et on referme le classeur.
Tout ça est fait par l´OS, t´as pas à t´en occuper normallement.
Voilà qu,arrivent les pointeurs: les pointeurs valent toujours 4 octets, car ce sont des nombres: imagine toi un int par exemble. Ce chiffre de ce int est en fait une valeur d,adresse. losqu´on dit qu´un pointeur pointe vers une adresse, c´est que son chiffre à l´intérieur est égual à la l´adresse de la variable quelle pointe. C´est très utile.
En pratique:
int *p;
Le C ( et C++) te simplifient la vie en t´offrant de symboles qui t´aident. * signifie que c´est un pointeur lors d´une création d´un pointeur.
p = &(variable);
ici: le chiffre de p est égual à la valeur de &. & signifie adresse ( ça renvoie l´adresse d´une variable)
Un * utilisé losqu´un pointeur déja créé signifie aller à l,adresse que vaut le chiffre de p. ici, p POINTANT sur variable, ça revient donc à écrire:
variable = 3;
À la fin donc de *p = 3;, variable vaut 3.
maintenant que tu sais ça, on peut faire des truc géniaux =)
int i1, i2;
int *pi, *pi2;
pi = &1;
pi2 = &2;
pi = pi2; /*le chiffre de pi est donc égual à celui de pi2, donc l,adresse contenue dans pi est donc celle de i2*/
Voilà. maintenant, le mauvais coté à ça: un pointeur ne peut pointer que sur un type au total. On déclare le type que que pointeur va pointer tout au long de son existance avant comme ceci:
TYPE *NOM;
ex.: int *hello;
MaStructure *haha;
Voilà, aussi, NULL est en fait une macro valant 0x00000000
- define NULL 0x00000000
en fait c´est pas vraiment ça, mais c´est proche.
Après, dire que pi = NULL; veut donc dire que elle pointe vers l,adresse 0x00000000. ATTENTION! Cette adresse est spéciale, est ne vaut rien! Il faut toujours donner une adresse à un pointeur, par soucis de sécurité, et NULL a été la solution logique, mais ça veut rien dire, et tenter d´utiliser NULL est dangereux!
Voilà, maintenant un spécial sur les ADM(Allocations Dynamiques de Mémoire)
malloc(size_t size)//Un size_t peut être renvoyé par sizeof()
C´est une fonction magique. Elle crée une variable vide de la taille donnée par size, et revoie l,adresse.
donc,
pi = ( int*) malloc(sizeof(int)); //pi pointe vers une adresse mais cette adresse n´a pas de variable.
Losqu´on a terminé avec, free(void * memblock) va exterminer le bloc à l´adresse qui a été donné par malloc.
free(pi);
Normallement, l´OS va s´occuper de la mémoire. le c/c++ te donne la possibilité de t´en occuper pour faire des truc intéressants, à une seule condition : "quand tu t,amuses avec la mémoire, tu t´occupe de l´allouer et de le détruire. "
N´oublie pas de détruire la mémoire avant de partir!
En c++, il existe des opérateurs qui font la même chose, en plus puissant, et il faut toujours les utiliser à la place de ceux du c lorsqu,on fait du c++.
new, delete, new[], delete[]. Ils sont simples:
new TYPE //Revoie l´adresse d´un nouveau TYPE
ex.: int *pi = new int
delete POINTEUR //Détruit le bloc à l´adresse du pointeur
ex.: delete pi;
new TYPE[NUMOFITEMS]//Appelé new[], comme new mais pour les tableaux: revoie l,adresse d´un tableau de TYPE avec NUMOFITEMS nombre d´éléments
ex.: int *pi2 = new int[33]
delete[] POINTEUR //Tu as deviné?
ex.: delete pi2;
Les pointeurs, c´est bien utile pour faire des tour des passe-passe. Enfin, bon, je pense que c´est tout, t´as d´audres questions?
Kelios
---------
