Comment fonctionnent les pointeurs vers les pointeurs en C ?

Question

Comment fonctionnent les pointeurs vers les pointeurs en C ? Quand les utiliseriez-vous ?

Answer 1

Supposons un ordinateur de 8 bits avec des adresses de 8 bits (et donc seulement 256 octets de mémoire). Voici une partie de cette mémoire (les chiffres en haut sont les adresses) :

 54   55   56   57   58   59   60   61   62   63   64   65   66   67   68   69
+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+
|    | 58 |    |    | 63 |    | 55 |    |    | h  | e  | l  | l  | o  | \0 |    |
+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+

Ce que vous pouvez voir ici, c'est qu'à l'adresse 63, la chaîne "hello" commence. Donc dans ce cas, si c'est la seule occurrence de "hello" en mémoire, alors,

const char *c = "hello";

.... définit c est un pointeur vers la chaîne de caractères (en lecture seule) "hello", et contient donc la valeur 63. c doit lui-même être stocké quelque part : dans l'exemple ci-dessus, à l'emplacement 58. Bien sûr, nous pouvons non seulement pointer vers des caractères, mais aussi vers d'autres pointeurs. Par exemple :

const char **cp = &c;

Maintenant cp Les points suivants c c'est-à-dire qu'il contient l'adresse de c (qui est de 58). Nous pouvons aller encore plus loin. Pensez-y :

const char ***cpp = &cp;

Maintenant cpp enregistre l'adresse de cp . Il a donc une valeur de 55 (d'après l'exemple ci-dessus), et vous l'avez deviné : il est lui-même stocké à l'adresse 60.

---

Quant à pourquoi on utilise des pointeurs sur des pointeurs :

• Le nom d'un tableau donne généralement l'adresse de son premier élément. Ainsi, si le tableau contient des éléments de type t une référence au tableau a le type t * . Considérons maintenant un tableau de tableaux de type t : naturellement une référence à ce tableau 2D sera de type (t *)* = t ** et est donc un pointeur vers un pointeur.
• Même si un tableau de chaînes de caractères semble unidimensionnel, il est en fait bidimensionnel, puisque les chaînes de caractères sont des tableaux de caractères. Par conséquent : char ** .
• Une fonction f devra accepter un argument de type t ** s'il s'agit de modifier une variable de type t * .
• Il existe de nombreuses autres raisons, trop diverses pour être énumérées ici.

Answer 2

Comment fonctionnent les pointeurs vers les pointeurs en C ?

Tout d'abord, un pointeur est une variable, comme n'importe quelle autre variable, mais qui contient l'adresse d'une variable.

Un pointeur vers un pointeur est une variable, comme n'importe quelle autre variable, mais qui contient l'adresse d'une variable. Cette variable se trouve être un pointeur.

Quand les utiliseriez-vous ?

Vous pouvez les utiliser lorsque vous avez besoin de renvoyer un pointeur vers une certaine mémoire sur le tas, mais sans utiliser la valeur de retour.

Exemple :

int getValueOf5(int *p)
{
  *p = 5;
  return 1;//success
}

int get1024HeapMemory(int **p)
{
  *p = malloc(1024);
  if(*p == 0)
    return -1;//error
  else 
    return 0;//success
}

Et tu l'appelles comme ça :

int x;
getValueOf5(&x);//I want to fill the int varaible, so I pass it's address in
//At this point x holds 5

int *p;    
get1024HeapMemory(&p);//I want to fill the int* variable, so I pass it's address in
//At this point p holds a memory address where 1024 bytes of memory is allocated on the heap

Il y a aussi d'autres utilisations, comme l'argument main() de chaque programme C a un pointeur sur un pointeur pour argv, où chaque élément contient un tableau de caractères qui sont les options de la ligne de commande. Vous devez cependant faire attention lorsque vous utilisez des pointeurs de pointeurs pour pointer vers des tableaux à 2 dimensions, il est préférable d'utiliser un pointeur vers un tableau à 2 dimensions à la place.

Pourquoi c'est dangereux ?

void test()
{
  double **a;
  int i1 = sizeof(a[0]);//i1 == 4 == sizeof(double*)

  double matrix[ROWS][COLUMNS];
  int i2 = sizeof(matrix[0]);//i2 == 240 == COLUMNS * sizeof(double)
}

Voici un exemple d'un pointeur vers un tableau à deux dimensions réalisé correctement :

int (*myPointerTo2DimArray)[ROWS][COLUMNS]

Vous ne pouvez cependant pas utiliser un pointeur vers un tableau à deux dimensions si vous souhaitez prendre en charge un nombre variable d'éléments pour les ROWS et COLUMNS. Mais si vous savez à l'avance que vous utiliserez un tableau à 2 dimensions.

Answer 3

J'aime cet exemple de code "réel" de l'utilisation de pointeur à pointeur, dans Git 2.0, commettre 7b1004b :

Linus a dit une fois :

J'aimerais que plus de gens comprennent le codage de base de bas niveau. Pas les trucs gros et complexes comme la recherche de nom sans verrouillage, mais simplement la bonne utilisation des pointeurs, etc.
Par exemple, j'ai vu trop de personnes qui suppriment une entrée de liste à lien unique en gardant la trace de l'entrée "prev", puis pour supprimer l'entrée, en faisant quelque chose du genre

if (prev)
  prev->next = entry->next;
else
  list_head = entry->next;

et à chaque fois que je vois du code comme ça, je me dis "Cette personne ne comprend pas les pointeurs". Et c'est malheureusement assez commun.

Les personnes qui comprennent les pointeurs utilisent simplement un " pointeur vers le pointeur d'entrée "et l'initialiser avec l'adresse de la tête de liste. Puis, au fur et à mesure qu'ils parcourent la liste, ils peuvent supprimer l'entrée sans utiliser de conditionnel, en faisant simplement un

*pp =  entry->next

L'application de cette simplification nous permet de perdre 7 lignes de cette fonction tout en ajoutant 2 lignes de commentaire.

-   struct combine_diff_path *p, *pprev, *ptmp;
+   struct combine_diff_path *p, **tail = &curr;

---

kumar souligne dans les commentaires l'article de blog " Linus sur la compréhension des pointeurs ", où Grisha Trubetskoy explique :

Imaginez que vous avez une liste liée définie comme :

typedef struct list_entry {
    int val;
    struct list_entry *next;
} list_entry;

Vous devez le parcourir du début à la fin et supprimer un élément spécifique dont la valeur est égale à la valeur de to_remove.
La façon la plus évidente de le faire serait :

list_entry *entry = head; /* assuming head exists and is the first entry of the list */
list_entry *prev = NULL;

while (entry) { /* line 4 */
    if (entry->val == to_remove)     /* this is the one to remove ; line 5 */
        if (prev)
           prev->next = entry->next; /* remove the entry ; line 7 */
        else
            head = entry->next;      /* special case - first entry ; line 9 */

    /* move on to the next entry */
    prev = entry;
    entry = entry->next;
}

Ce que nous faisons ci-dessus est :

• en itérant sur la liste jusqu'à ce que l'entrée soit NULL ce qui signifie que nous avons atteint la fin de la liste (ligne 4).
• Lorsque nous rencontrons une entrée que nous voulons supprimer (ligne 5),
  • nous assignons la valeur du pointeur suivant actuel au pointeur précédent,
  • éliminant ainsi l'élément courant (ligne 7).

Il y a un cas spécial ci-dessus - au début de l'itération il n'y a pas d'entrée précédente ( prev es NULL ), et donc pour supprimer la première entrée de la liste, il faut modifier head lui-même (ligne 9).

Ce que Linus disait, c'est que le code ci-dessus pourrait être simplifié en faisant de l'élément précédent un pointeur vers un pointeur plutôt qu'un simple pointeur .
Le code ressemble alors à ceci :

list_entry **pp = &head; /* pointer to a pointer */
list_entry *entry = head;

while (entry) {
    if (entry->val == to_remove)
        *pp = entry->next;

    pp = &entry->next;
    entry = entry->next;
}

Le code ci-dessus est très similaire à la variante précédente, mais remarquez comment nous n'avons plus besoin de surveiller le cas particulier du premier élément de la liste, puisque pp n'est pas NULL au début. Simple et astucieux.

En outre, quelqu'un dans ce fil a commenté que la raison pour laquelle c'est mieux est parce que *pp = entry->next est atomique. Il n'est certainement PAS atomique .
L'expression ci-dessus contient deux opérateurs de déréférencement ( * y -> ) et une affectation, et aucune de ces trois choses n'est atomique.
Il s'agit d'une idée fausse très répandue, mais hélas, presque rien en C ne doit être considéré comme atomique. (y compris le ++ y -- opérateurs) !

Answer 4

Lorsque nous avons abordé les pointeurs dans un cours de programmation à l'université, nous avons reçu deux indications sur la manière de commencer à les apprendre. Le premier consistait à regarder Le plaisir du chien d'arrêt avec Binky . La deuxième était de penser à la Les yeux de l'aiglefin un passage de l'œuvre de Lewis Carroll De l'autre côté du miroir

"Vous êtes triste", dit le chevalier d'un ton inquiet : "Laisse-moi te chanter une chanson pour te réconforter."

"C'est très long ?" demanda Alice, car elle avait entendu beaucoup de poésie ce jour-là.

"C'est long", dit le chevalier, "mais c'est très, très beau". Tous ceux qui m'entendent la chanter - ou bien ils en ont les larmes aux yeux, ou bien -"

"Ou sinon quoi ?" dit Alice, car le chevalier avait fait une pause soudaine.

"Ou sinon, ça ne le fait pas, tu sais. Le nom de la chanson s'appelle 'Haddocks' Eyes'."

"Oh, c'est le nom de la chanson, c'est ça ?" Alice a dit, en essayant d'être intéressée.

" Non, vous ne comprenez pas ", dit le chevalier, l'air un peu vexé. "C'est le nom qu'on lui donne. Le nom réel est 'L'homme âgé'."

"Alors j'aurais dû dire 'C'est le titre de la chanson' ?" Alice s'est corrigée.

"Non, vous ne devriez pas : c'est tout autre chose ! La chanson s'appelle 'Ways And Means' : mais ce n'est que son nom, vous savez !"

"Alors, quelle est la chanson ?" dit Alice, qui était à ce moment-là complètement déconcertée.

"J'y venais", a déclaré le Chevalier. "La chanson est vraiment 'A-sitting On A Gate' : et l'air est de ma propre invention."

Answer 5

Vous voudrez peut-être lire ceci : De pointeur à pointeur

J'espère que cela aidera à clarifier certains doutes de base.