dyn. void* array

Plasmaboy

Hallo Leute !

Ich möchte ein Typunabhängiges dynamisches Array erzeugen.
bsp:

int i = 10;
void *pArray = malloc (....);

So jetzt ist ja der Speicher allokiert.
Nun ist aber das Problem, diesem Array Werte zuzuweisen.

pArray + 3 = &i; // 1 Zuweisung über Pointerarithmetik

oder

*(pArray +2) = &i; / 2

Das Problem ist nun ,das bei der ersten Lösung, der Compiler sich beschwert, dass er die Größe von void * nicht kennt. (sizeof(void*) geht aber)
Bei dem zweiten versuch ist das Problem, dass man einen void * nicht dereferenzieren kann.
Mir fallen noch zwei Dinge ein, welche mir aber unsauber vorkommen, dieses Prob zu lösen.
1. Vor der zuweisung wandel ich den void Pointer in einen int Poiter
2. Ich benutzt Funktionen wie memcpy oder soetwas um in den Speicher zu schreiben.

Wenn jemand eine Lösung kennt, antworte mir bitte

crass

nr.1 ist okay würd ich sagen

Plasmaboy

Also in ein int Pointer umwandeln ?
Ist es denn sicher, dass alle Pointer die gleiche Größe in Bytes haben ?

Plasmaboy

Habe es gelöst:
Und zwar wollte ich ein void** Array.
Hier meine Lösung:

#include <stdio.h>
#include <stdlib.h>

void *memAlloc(void *memPtr, int size)
{
    void *tmpPtr = NULL; // Zwischenspeicherung des Pointers

    // Zeigt der übergebene Pointer schon auf einen Speicherbereich ?
    if (memPtr != NULL)
    {
        tmpPtr = realloc(memPtr, size);
    }
    else
    {
        tmpPtr = malloc(size);
    }
    // Konnte Speicher allokiert werden ?
    if (tmpPtr != NULL)
    {
        return tmpPtr;
    }
    else
    {
        return NULL;
    }
}

typedef struct
{
    void **pArray; // hier ist das Array
}CONTAINER;

int main(void)
{
    int ia[5] = {0,1,2,3,4};
    int i = 0;
    CONTAINER con = {NULL};

    con.pArray = memAlloc(NULL, 10 * sizeof(void*));
    for (i=0;i<5;i++)
    {
        *(con.pArray+i) = (void*) &ia[i];
        printf ("\n%d", *(int*) *(con.pArray+i));
    }
    return 0;   
}

Besten dank für alles !

Plasmo