Array aus void-Pointern?

Hi,

ich glaube, ich stehe gerade ziemlich auf der Leitung...also ich würde gerne Pointer auf andere Speicherbereiche/Strukturen in einem eigenen Speicherbereich ablegen. Das soll per void* geschehen, da verschiedene Strukturen verwendet werden können. Leider verweigert mir de Compiler, dass ich ein void-Pointer-Array über dessen Indexwerte anspreche:

void *store; // hier sollen die Pointer gespeichert werden

store=malloc(size*sizeof(void*)); // bis zu "size" Pointer können verwaltet werden
...
store[index]=puffer; // hier meckert der Compiler...

Aber wie bekomme ich meine void-Pointer dann an einer bestimmten Position im Array abgelegt?

Was spricht der Compiler genau? Schonmal mit nem Cast probiert?

void *store = (void *) malloc (size*sizeof(void*));

SeppJ

store soll doch wohl eher ein Zeiger auf viele Zeiger auf void sein.

store ist ein Zeiger auf void.

Du möchtest aber einen Zeiger auf einen void-Zeiger haben.

void **store;

void **store = (void **) malloc (size*sizeof(void**));

RateFux schrieb:

void **store = (void **) malloc (size*sizeof(void**));

sizeof(void**) ? Ich würde mal sagen sizeof(void**) == sizeof(void*)

Das Problem liegt nicht am cast, das braucht C nicht (aber C++).

Das liegt daran, das der Compiler nichts mit einem void-Array anfangen kann, da void keine Größe hat. (ist sizeof(void) eigenttlich definiert?)

DirkB schrieb:

Das Problem liegt nicht am cast, das braucht C nicht (aber C++).

Das liegt daran, das der Compiler nichts mit einem void-Array anfangen kann, da void keine Größe hat. (ist sizeof(void) eigenttlich definiert?)

Er meinte ja void-Pointer-Array. Das ist ja was anderes.

Hat ein Pointer nicht immer die gleiche Größe? Immerhin befindet sich darin nur die Adresse an der das Objekt, auf das er zeigt, liegt. Demnach sollte sizeof(void**) wahrscheinlich auch gehen, auch wenn es nicht schön ist.

Steffo schrieb:

Er meinte ja void-Pointer-Array. Das ist ja was anderes.

Meinte er, hat er aber nicht gemacht.

Der Fehler kann doch nur im Detail stecken!

void **v_arr[10] = (void **[10]) malloc(10 * sizeof(void*));

Fehler: Typkonvertierung gibt Feldtyp an

void **v_arr = (void **) malloc(10 * sizeof(void*));
void *a = NULL;
v_arr[0] = a;
v_arr[1] = NULL;

EDIT: Was mach ich eigentlich? RateFux kam mir doch schon längst zuvor.

Wutz

RateFux schrieb:

void **store = (void **) malloc (size*sizeof(void**));

Anfängerhafter Fehler.
Besser:

void **store = malloc (size*sizeof*store);

Noch besser, da man hier gefahrlos für alle Elemente free() verwenden kann (free ist für NULL definiert):

void **store = calloc(size,sizeof*store);

Wutz

DirkB schrieb:

(ist sizeof(void) eigenttlich definiert?)

Nein.
void ist ein 'incomplete type' und somit ebenso wie Funktionen (nicht Funktionszeiger) und Bitfelder für sizeof undefiniert.

Wutz

Steffo schrieb:

Ich würde mal sagen sizeof(void**) == sizeof(void*)

Auch falsch bzw. eine unzulässige Interpretation des Standards, der keinerlei Größenangaben vorgibt sondern derlei als implementierungsabhängig bezeichnet.
Allenfalls kann man ableiten, dass sizeof(void*) >= sizeof(Zeiger auf Basistypen,Funktionen,Zeiger,struct,union) ist.
Und Zeiger, die nicht auf den gleichen Referenztyp zeigen, sind sowieso inkompatibel (einzige definierte Ausnahme void*), sizeof dafür dann erst recht. (void != void*).

Wutz

leme schrieb:

Hat ein Pointer nicht immer die gleiche Größe?

Nein, bzw. nur wenn er den gleichen Referenztyp hat (alle struct+union jeweils hierbei gleichbehandelt).
Historisch soll man pragmatischerweise von sizeof(char*)==sizeof(signed char*)==sizeof(unsigned char*)==sizeof(void*) bei ANSI C Compilern ausgehen können.

Wutz schrieb:

Steffo schrieb:

Ich würde mal sagen sizeof(void**) == sizeof(void*)

Auch falsch bzw. eine unzulässige Interpretation des Standards, der keinerlei Größenangaben vorgibt sondern derlei als implementierungsabhängig bezeichnet.
Allenfalls kann man ableiten, dass sizeof(void*) >= sizeof(Zeiger auf Basistypen,Funktionen,Zeiger,struct,union) ist.
Und Zeiger, die nicht auf den gleichen Referenztyp zeigen, sind sowieso inkompatibel (einzige definierte Ausnahme void*), sizeof dafür dann erst recht. (void != void*).

Hä? Vieles von dem habe ich doch gar nicht gesagt, ich habe lediglich gesagt, dass ein void-Zeiger gleich groß ist wie ein void-Zeiger der auf einen void-Zeiger zeigt. Ist das falsch?!

Wutz

Ja.
Wer lesen kann ist klar im Vorteil.
Und wissen was du gesagt hast, solltest du schon wissen.
Du hast gesagt sizeof(void**)==sizeof(void*), d.h. ein Zeiger auf einen void-Zeiger ist gleich groß einem Zeiger auf void.
void und void* sind unterschiedliche Typen und deshalb sind Zeiger darauf inkompatibel und somit einen gleiche Größe nicht garantiert bzw. im Standard definiert (schon gar nicht explizit).

Ist das richtig oder falsch?

void **v_arr = malloc(size * sizeof(void*));

Das ist richtig.

Für welche Frage denn?

Wenn du so fragst, gibt es doch bestimmt ein Problem an anderer Stelle.
Wie sieht die aus?