Was bedeutet (void **) in C?

Question

Ich würde das nachschlagen, aber ehrlich gesagt würde ich nicht wissen, wo ich anfangen soll, weil ich nicht weiß, wie es heißt. Ich habe Variablen auf Funktionen wie diese weitergegeben gesehen:

myFunction((void**)&variable); 

Welche das Heck aus mir verwirrt verursachen alle diejenigen mir bekannt vorkommen; Ich habe sie noch nie so zusammen gesehen.

Was bedeutet das? Ich bin ein Newb, also weniger Jargon, desto besser, danke!

Answer 1

Es ist eine Umwandlung in einen Zeiger auf einen Zeiger void.

Sie sehen dies sehr oft mit Funktionen wie CoCreateInstance() auf Windows-Systemen.

ISomeInterface* ifaceptr = 0; 
HRESULT hr = ::CoCreateInstance(CLSID_SomeImplementation, NULL, CLSCTX_ALL, 
    IID_ISomeInterface, (void**)&ifaceptr); 
if(SUCCEEDED(hr)) 
{ 
    ifaceptr->DoSomething(); 
} 

Der gegossenen wandelt den Zeiger auf einen ISomeInterface Zeiger in einen Zeiger auf einen Zeiger, so dass voidCoCreateInstance()ifaceptr auf einen gültigen Wert einstellen.

Da es sich um einen Zeiger auf einen void Zeiger handelt, kann die Funktion abhängig von der Schnittstellen-ID Zeiger (z. B. IID_ISomeInterface) ausgeben.

Answer 2

Das wandelt &variable in einen void** um (also einen Zeiger auf einen Zeiger auf void).

Zum Beispiel, wenn Sie etwas entlang der Linien von haben

void myFunction(void** arg); 

int* variable; 

Dieser übergibt die Adresse von variable (das ist, was die unary- & tut, ist es die Adresse nimmt) zu myFunction().

Answer 3

Es ist ein Zeiger auf einen Zeiger auf eine Variable mit einem nicht angegebenen Typ. Alle Zeiger haben die gleiche Größe, also bedeutet void* nur "einen Zeiger auf etwas, aber ich habe keine Ahnung, was es ist". Ein void** könnte auch ein 2D-Array eines nicht spezifizierten Typs sein.

Answer 4

void* ist ein "Zeiger auf alles". ist eine andere Ebene der Indirektion - "Zeiger auf Zeiger auf alles". Im Grunde übergeben Sie das, wenn Sie zulassen möchten, dass die Funktion einen Zeiger eines beliebigen Typs zurückgibt.

&variable übernimmt die Adresse der Variablen. variable sollte bereits eine Art von einem Zeiger dafür sein, um zu arbeiten, aber es ist wahrscheinlich nicht void * - es könnte sein, sagen int *, so unter seiner Adresse würde in int ** führen. Wenn die Funktion void ** annimmt, müssen Sie auf diesen Typ umwandeln.

(Natürlich muss es tatsächlich ein Objekt des richtigen Typs zurückgeben, sonst Code Aufruf auf der Bahn wird scheitern, wenn er versucht es den falschen Weg zu verwenden.)

Answer 5

Die Variablen ein Zeiger auf etwas von undefiniertem (void) Typ. Der Operator & gibt die Adresse dieser Variablen zurück, so dass Sie jetzt einen Zeiger auf einen Zeiger von etwas haben. Der Zeiger wird also durch Referenz in die Funktion übernommen. Die Funktion hat möglicherweise einen Nebeneffekt, der den von diesem Zeiger referenzierten Speicher ändert. Mit anderen Worten, der Aufruf dieser Funktion könnte das Etwas verändern, auf das der ursprüngliche Zeiger verweist.

Answer 6

es Stück für Stück auseinander nehmen ...

myFunction nimmt einen Zeiger auf einen Zeiger vom Typ void (das ist ziemlich viel bedeutet, könnte es zu etwas Punkt). Es könnte so etwas wie folgt lauten:

myFunction(void **something); 

Alles, was Sie übergeben, muss diesen Typ haben. Du nimmst also die Adresse eines Zeigers und wirfst sie mit (void **), um es zu einem leeren Zeiger zu machen. (Im Grunde strippt es von irgendeiner Idee darüber, worauf es hinweist - worüber der Compiler ansonsten winseln könnte.)

Dies bedeutet, dass & Variable die Adresse (& dies tut) eines Zeigers ist - so Variable ist ein Zeiger. Um was? Wer weiß!

Hier ist eine vollständigere Schnipsel, eine Vorstellung davon zu geben, wie das passt zusammen:

#include <stdio.h> 

int myInteger = 1; 
int myOtherInt = 2; 
int *myPointer = &myInteger; 

myFunction(void **something){ 
    *something = &myOtherInt; 
} 

main(){ 
    printf("Address:%p Value:%d\n", myPointer, *myPointer); 
    myFunction((void**)&myPointer); 
    printf("Address:%p Value:%d\n", myPointer, *myPointer); 
} 

Wenn Sie diese kompilieren und ausführen, es diese Art der Ausgabe geben sollte:

Address:0x601020 Value:1 
Address:0x601024 Value:2 

Sie können sehen, dass myFunction den Wert von myPointer geändert hat - was nur möglich war, weil die Adresse des Zeigers übergeben wurde.

Answer 7

#include <stdio.h> 
#include <iostream> 

int myInteger = 1; 
std::string myOtherInt = "Test"; 
int *myPointer = &myInteger; 

void myFunction(void **something) 
    { 
     *something = &myOtherInt; 
    } 

int main(){ 
    //printf("%d\n", *myPointer); 
    printf("Address:%p Value:%d\n", myPointer, *myPointer); 
    myFunction((void**)&myPointer); 
    printf("Address:%p Value:%d\n", myPointer, *myPointer); 
}