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é.