Generic data type in C [ void * ] [duplicate]

Answer 1

You are copying the integer value (55) into the pointer int_out. Whatever lies at (the next 4 to 8 bytes at) address 55, it is unlikely to have the numerical value 55. Instead, try

int int_in = 55;
int int_out;
store   ( storage_int, &int_in, sizeof(int));
retrieve ( &int_out, storage_int, sizeof(int));
assert  ( 55 == int_out);

Another problem with your code: in the char_in/char_out parts, you are only ever copying pointer values. This works (in this case), but is not likely what you really intended, or is it? If you really want to store the pointer, you can skip the store and retrieve part:

char* str_in = "hello, world";     // Original value
void* generic_ptr = str_in;        // ... a pointer to which is stored in some data structure
char* str_out = generic_ptr;       // ... which can later be retrieved

will work as well. On the other hand: if you intend to store the actual content of the string, you have to copy it (like, with _strdup as in your second example), and save the pointer to the copy of the string:

char* str_in = _strdup("copy me");
void* generic_ptr = str_in;         // Gets stored in your data structures

Answer 2

Dirk is totally correct. Another way to express this, is that there is no space allocated to put retrieved data in.

try:

int_in = 55;
void* int_out = malloc (sizeof (int_in));
store   ( storage_int, &int_in, sizeof(int));
retrieve ( int_out, storage_int, sizeof(int));
assert  ( 55 == *(int*)int_out);

Of course, you may want to use something other than malloc(), and there is no check to see if malloc() failed, but this should get you on the right track.

Answer 3

It's much better to use a union of all types you will need instead of void*, combined with an enumeration of the selected type. If you don't have a finite list of types, then use a struct containing void* pointer and the size allocated at least.

For example:

struct ANYTYPE
{
    enum {
      typUndefined,
      typInt,           // 1
      typUint,
      typString,
      typByteString,
      typLong,          // 5
      typFloat,
      typDouble,
    } iType;

    void* value;
};

This allows you to easily deallocate the memory correctly and make generic code that can analyze the type before acting on the value. You have a similar option with union:

struct ANYTYPE
{
    enum {
      typUndefined,
      typInt,           // 1
      typUint,
      typString,
      typLong
    } iType;

    union
    {
        int i;
        unsigned int u;
        char* s;
        long l;
    } value;
}

In a union, all elements are using same memory space and only one should be accessed. Via the enumeration, you know which element should be accessed. Of course you don't have OO protection like in C++, so you need to be sure you correctly set the enumeration everywhere you use this struct.

Answer 4

You're overwriting the pointer, then dereferencing it... if your code looked like this it would work... but that may not be what you're after.

    int int_out;
    store   ( storage_int, &int_in, sizeof(int));
    retrive ( &int_out, storage_int, sizeof(int));
    assert  ( 55 == int_out);

or:

    int *int_out;
    store   ( storage_int, &int_in, sizeof(int));
    retrive ( &int_out, storage_int, sizeof(int));
    assert  ( 55 == (int)int_out);

However, in the second case this is a bit dubious, because it assumes that both 'int' and 'int*' are the same size, so you're able to store one on top of the other when retrieving. I believe this isn't the case on all systems.