Ici, je vais expliquer le notion de deferencement de pointeurs en C.

Un pointeur contient une addresse qui identifie l’addresse d’une variable.

lorsque l’on veut acceder a une valeur, une donnee localise a une addresse memoire qui est pointe par un pointeur, on apeller cela deferencer un pointeur.

en C ceci est un pointeur de char :

const char*  p = “abc”;

on utilise 4 octets (bytes), 4 car on mets en memoire 4 caractere a, b, c et 0 pour indiquer au C ou ce termine la chaine de caractere.

tous ceci est stocke dans un addresse memoire quelconque et sont addresse est stocke dans la variable p

addresse memoire                                     variable                               contenue
1000                                                                                                                      ‘a’
1001                                                                                                                      ‘b’
1002                                                                                                                      ‘c’
1003                                                                                                                        0
….
2000-2003                                                                p                                         1000

pour deferencer p on utilise une de ces code :

assert(*p == 'a');le premier caractere a  l'addresse p sera 'a'

assert(p[1] == 'b'); p[1] deference le pointeur cree en ajoutant p et une  fois la taille de la chose que p pointe dans ce cas ce un char de taille 1 octet 

assert(*(p + 1) == 'b');on ajoute 1 au pointeur soit addresse 1001

p++; va faire pointer sur addresse 1001 et

assert(*p == 'b'); et p pointera vers 'b'

Dans le cas ou on utilise l’allocation de memoire dynamique avec un malloc

int* p = malloc(sizeof(int)); reserve de la memoire a un endroit  quelconque

*p = 10; on deference le pointeur de la memoire et on ecrit une valeur

fn(*p);  appelle fonction fn et passe la valeur a l'addresse de p.

(*p) += 3; change la valeur de p et ajoute 3.

free(p); libere la memoire alloue dynamiquement.

un cas pour les void  * :

le compilateur nous transmettra un message d’erreur si on essaie de deferencer un void * car il ne sait pas la taille de la variable qu’il  pointe.

si  par exemple la variable pointe est un char qui est un octet le compilateur accedera ce seul octet. si il sagit d’un double il y aura plus de memoire alloue mais aussi son architecture sera differente. avant de deferencer ce pointeur generique void * nous devrons le caster vers le type de valeur desire.

quelques exemples pour le deferencement :

int nb = 6;
void *ptr;
ptr = &nb; /* ici dans la case memoire de ptr on range l’addresse de nb. */
printf(“\nLa valeur de nb est : %d”,*((int*)ptr)); /* on caste le ptr en pointeur de int, puis on accede a sont contenant grace a l’etoile exterieure (*…..). */

ou alors :

int nbptr
void* ptr = NULL;
ptr = &nb;
nbptr = *((int*)ptr); /* meme explication que au dessus, le pointeru

Le pointeur void* ne pointe vers rien de particulier, si l’on veut le deferencer, il faut d’abors changer de type de pointeur, dans ce cas ci il faut passer par un pointeur de int.
soit l’ecriture (int*) qui caste le pointeur void* appeler ptr en pointeur de int, mais ce n’est pas fini.
notre pointeur ressemble a int* ptr, pour acceder a la case memoire par ce pointeur il faut donc regarder ou il pointe ou le deferencer avec *((int*) ptr) qui va donc extirper la valeur int de la case memoire.