wie zu verwenden void ** pointer, richtig?

Ich versuche, mit einem Doppel - void pointer, aber ich bin ein wenig verwirrt über die Verwendung.
Ich habe eine struct enthält eine void ** array.

struct Thing{
    void ** array;
};

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

Also, Wenn ich zuweisen möchten ein anderes Objekt zu jedem Zeiger, und versuchen Sie, um den Wert abzurufen

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

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

dann habe ich eine andere Funktion, die (void *) itemdie Punkte um jede Zelle, nicht die some_object_ptr.

Wenn ich will, um den Wert abzurufen, die Spitzen, von some_object_ptr,
soll ich tun,

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

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

komisch ist, dass wenn ich in den array die array-subscript-Methode konnte ich nicht verwenden, option 4, option nur 3; und wenn ich *(c->array + index) konnte ich nur opt.4. und nicht opt.3. ..

Kann jemand bitte sagen Sie mir dazu? Wenn ich alle ungültigen Annahmen, dann könnten Sie das bitte korrigieren Sie mich?

InformationsquelleAutor der Frage in His Steps | 2012-01-27

  1. 22

    Einen void ** ist nur ein Zeiger auf einen Zeiger auf Speicher mit einem nicht näher definierten Typ. Sie können nur zu dereferenzieren es einmal (da kann man nicht dereferenzieren eine void *). Aber abgesehen davon, es ist im Grunde wie jeder andere Zeigertyp. Wenn es Ihnen hilft, denken Sie an die gleiche Weise, als würden Sie mit int *.

    So, in Ihrer speziellen situation, die wir haben:

    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;

    Dann array ist ein Zeiger auf ein ganzes array, während *array ist ein Zeiger auf das erste element, da es äquivalent ist zu array[0].

    InformationsquelleAutor der Antwort Sylvain Defresne

  2. 2

    Einen quick-Tipp, - Zeiger: wenn Sie Gießen, dann sind Sie wahrscheinlich etwas falsch machen.

    Als für Ihre Frage. Ich bin nicht sicher, was item ist Ihr problem. In Ihrem ersten Teil haben Sie bereits erfahren, wie Sie Zugang Mitglied im array. Sie könnte es einfach:

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

    Wenn Sie müssen die Adresse des pointer auf index:

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

    In den zweiten Teil, den man nicht dereferenzieren Sie den Zeiger (+ option), oder nehmen Sie sich die Adresse von array Ergebnis, da es automatisch dereferenziert.

    BEARBEITEN:
    Ich denke, ich weiß jetzt, was Sie wollen. Sie haben eine ähnliche Funktion wie mein zweiter oben, aber es ist:

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

    Möchten Sie dereferenzieren den Wert von dieser Funktion zurückgegeben wird, und den Zugriff auf das Objekt. In diesem Fall können Sie nur die Option 4 sicher. Da Sie nicht über den index, können Sie nicht wechseln Sie zu einer anderen Zelle (Sie weiß nicht, ob Sie am Ende des Arrays, oder am Anfang - also keine Zusätze oder Abzüge). Sie können nur beheben, der Fehler der oben genannten Funktion: cast void **und dann dereferenzieren: *(void **)item. Dies wird Ihnen eine void *. Wenn Sie möchten, um den Zugriff auf das Objekt wies aus dieser Zelle, Sie müssen gegossen, die auf den korrekten Typ: some_object_ptr *obj = *(void**)item.

    InformationsquelleAutor der Antwort vhallac

  3. 1

    Die Tatsache, die Sie arbeiten mit void* und void** egal, Zeiger-Arithmetik funktioniert immer noch gut, so dass beide Optionen, die Sie schrieb, sind richtig.

    Hier ein Beispiel:

    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;
}

    Da es void* Sie können es Zeiger auf was auch immer, nur vergessen Sie nicht, es zu werfen, um original-Typ, bevor Sie es verwenden 😉

    InformationsquelleAutor der Antwort LihO

  4. -1

    Allmächtigen push!

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

    Allmächtigen ziehen!

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

    Achtung verlieren/gewinnen Ziffern

    InformationsquelleAutor der Antwort Fabio

Schreibe einen Kommentar