C double pointeur

struct counter{ long long counter; } struct instruction{ struct counter *counter int repetitions; void (*work_fn)(long long *); }; int ncounter; //number of counters struct counter *counter; //counter array int nthreads; //number of threads int *ninstructions; //number of instructions struct instruction **instructions; 

Comment cela fonctionne-t-il réellement? J’ai des problèmes avec ** pointeurs

Un ** est juste un pointeur sur un pointeur. Ainsi, lorsqu’une instruction* contient l’adresse d’une structure d’ instruction , une instruction** contient l’adresse d’une instruction* qui contient l’adresse d’un object d’ instruction .

Pour accéder à l’ instruction pointée par le pointeur pointé par une instruction** , il suffit d’utiliser deux astérisques au lieu d’un, comme (**p).repetitions ou quelque chose de similaire.

Vous pouvez le visualiser comme ceci:

 instruction* ----> instruction instruction** ----> instruction* ----> instruction 

Rappelez-vous cependant que vous struct instruction** instructions; simplement l’ struct instruction** instructions; ne crée pas réellement une structure d’ instruction . Il crée simplement un pointeur qui contient une valeur de déchets. Vous devrez l’initialiser:

 struct instruction inst; // set members of inst... *instructions = &inst; ... (*instructions)->repetitions++; // or whatever 

Cependant, il semble que vous utilisiez une instruction** pour pointer sur un tableau d’ instruction* s. Pour initialiser le tableau, vous avez besoin d’une boucle for :

 instructions = malloc(sizeof(struct instruction*) * num_of_arrays); for (i = 0; i < num_of_arrays; ++i) instructions[i] = malloc(sizeof(struct instruction) * size_of_each_subarray); 

Et ensuite, vous pouvez accéder à un élément tel que des instructions[i]->datamember .

struct instruction **instructions; // How does this actually works ? I am having trouble with ** pointers

Je ne sais pas quel est le véritable problème, mais je vais essayer de répondre à la question.

Le double pointeur est un pointeur sur un pointeur. Il peut être utilisé comme tableau de pointeurs par exemple (si vous allouez de la mémoire en conséquence). Par exemple:

 instructions = malloc(5*sizeof(struct instruction*)); for (int i = 0; i < 5; i++) instructions[i] = malloc(sizeof(struct instruction)); 

Et vous avez un beau tableau de 5 pointeurs pour struct instruction . Utilisez-le comme ceci:

 instructions[0]->repetitions = 0; 

instructions est un pointeur sur un pointeur sur une struct instruction .

Cela signifie que *instructions vous donneront un pointeur sur une struct instruction . Ce type de construction est souvent utilisé pour créer un tableau dynamic de pointeurs sur un type composé.