comment utiliser le pointeur ** void correctement?

Je suis en train d'utiliser un double void pointeur mais je suis un peu confus au sujet de l'utilisation.
J'ai un struct qui contient un void ** tableau.

struct Thing{
    void ** array;
};

struct Thing * c = malloc (sizeof(struct Thing));
c->array = malloc( 10 * sizeof(void *) );

Donc, Si je veux affecter un objet différent à chaque pointeur et d'essayer de récupérer la valeur

 //Option 1
 *(c->array + index) = (void *) some_object_ptr;

 //Option 2
 c->array[index] = (void *) some_object_ptr;

puis, j'ai une autre fonction qui donne (void *) item que des points à chaque cellule, pas la some_object_ptr.

Si je veux récupérer la valeur pointée par some_object_ptr,
dois-je faire

 function return type is 'void *' and takes argument 'void *'
 //Option 3 
 return (void**) item

 //Option 4
 return *((void**)item)?

la chose étrange est que lorsque j'ai utilisé la matrice de l'indice de tableau de la méthode, je ne pouvais pas utiliser l'option 4, seule l'option 3; et lorsque je l'ai utilisé *(c->array + index) je ne pouvais que refuser de recevoir.4. et ne pas choisir.3. ..

Quelqu'un peut-il me dire à ce sujet? Si je fais quelque erreurs, alors pourriez-vous s'il vous plaît corrigez-moi?

source d'informationauteur in His Steps | 2012-01-27

  1. 21

    Un void ** est juste un pointeur vers un pointeur vers la mémoire avec un type non spécifié. Vous pouvez seulement de déréférencer une fois (puisque vous ne pouvez pas déréférencer un void *). Cependant, en dehors de cela, il est fondamentalement comme n'importe quel autre type de pointeur. Si cela vous aide, pense que de la même manière que vous le feriez avec int *.

    Donc, dans votre cas particulier, nous avons:

    void** array;
int arrayLen = 10;
array = (void**)malloc(arrayLen * sizeof(void*));

some_type_t* some_object_ptr;    
//The following two assignment are equivalent since in C,
//array[index] <=> *(array + index)
array[index] = (void*)some_object_ptr;
*(array + index) = (void*)some_object_ptr;

    Puis array est un pointeur vers le tableau entier, tandis que *array est un pointeur vers le premier élément, puisqu'il est équivalent à array[0].

  2. 2

    Une rapide allusion à propos des pointeurs: si vous lancez un sort, vous avez probablement fait quelque chose de mal.

    Comme pour votre question. Je ne suis pas sûr de ce que item est à votre problème. Dans votre première partie, vous avez déjà découvert comment l'acces a un membre de votre tableau. Vous pouvez simplement l'utiliser:

    void *get_item(Thing *c, int index)
{
    return *(c->array + index); //or return c->array[index];
}

    Si vous avez besoin de l'adresse du pointeur à l'index:

    void **get_item_cell(Thing *c, int index)
{
    return c->array + index; //or return &c->array[index];
}

    Dans la deuxième partie, vous n'avez pas déréférencer le pointeur (+ option), ou de prendre l'adresse de la matrice de résultat, puisqu'il automatiquement déréférence.

    EDIT:
    Je pense que je sais maintenant ce que vous voulez. Vous avez une fonction similaire à mon deuxième ci-dessus, mais il est:

    void *get_item_cell(Thing *c, int index)
{
    return (void *)(c->array + index);
}

    Vous voulez de déréférencement de la valeur retournée par cette fonction, et d'accéder à l'objet. Dans ce cas, vous pouvez uniquement utiliser l'Option 4 en toute sécurité. Puisque vous n'avez pas l'indice, vous ne pouvez pas vous déplacer à n'importe quelle autre cellule (vous ne savez pas si vous êtes à la fin du tableau, ou au début - donc pas d'additions ou de soustractions). Vous ne pouvez résoudre l'erreur de la fonction ci-dessus: fonte à void **puis de déréférencement: *(void **)item. Cela vous donnera une void *. Si vous souhaitez accéder à l'objet pointé à partir de cette cellule, vous avez besoin de jeter que pour le bon type de bien: some_object_ptr *obj = *(void**)item.

  3. 1

    Le fait que vous travaillez avec void* et void** n'a pas d'importance, l'arithmétique des pointeurs fonctionne toujours très bien, de sorte que les deux options que vous avez écrit est correct.

    Voici un exemple:

    struct Thing
{
    void ** array;
};

struct Object
{
    int i;
    char c;
};

int main ()
{

    struct Thing * c = malloc (sizeof(struct Thing));
    c->array = malloc(10 * sizeof(void*));

    struct Object * o = malloc (sizeof(struct Object));
    o->i = 2; o->c = 'a';

    *(c->array + 2) = o;

    printf("Object: i = %d, c = %c\n", ((Object*)c->array[2])->i, ((Object*)c->array[2])->c);

    free(o);
    free(c->array);
    free(c);
    return 0;
}

    Puisque c'est void* vous pouvez y mettre le pointeur à que ce soit, juste de ne pas l'oublier cast vers le type d'origine avant de l'utiliser 😉

  4. -1

    Tout-puissant pousser!

    any_type x ;
void * v = * ( void * * ) & x ;

    tout-puissant pull!

    void * v ;
any_type x = * ( any_type * ) & v ;

    méfiez-vous de perdre/gagner de chiffres