Solved: C programming: confused by void *

[divideby0]

I'm trying out void * types, but I'm not exactly sure how they work. If I wanted an int array with 10 elements, would it be declared as

void *int_p = (int *)malloc(sizeof(int) * 10);
 

Here's where I'm lost; I've read not to cast malloc because malloc returns void * regardless. How then would malloc know what the type was?

How would I access the elements?

int i;
for(i=0; i < 10; ++i) {
   *(int *)(int_p + i) = i * 5 + i;
   printf("%d", *(int *)(int_p + i));
}
 

I tried something like above without any warnings or errors, but is it correct? Any help would be greatly appreciated. Thank you in advance.

[Brian Connelly]

Im not sure, but I think your first problem is understanding data types. Void is not a data type. Here is a start. http://msdn.microsoft.com/en-us/libr...(v=vs.80).aspx

[divideby0]

Thank you for the reply; I apologize for any confusion, by types, I meant converting to int, float, char, etc.

typedef struct {
    void *data1;
    void *data2;
    void *data3;
} void_ptrs;
 
void_ptrs test = { NULL, NULL, NULL };
 
test.data1 = malloc(sizeof(int));   // single int
test.data2 = malloc(sizeof(float);  // single float
test.data3 = malloc(100);           // char [100]
 
if(test.data1 && test.data2 && test.data3) {
   *(int *)(test.data1) = 100;
   *(float *)(test.data2) = 2.5;
   strcpy((char *)test.data3, "testing");
   ...
}

That's the sort of thing I'm wanting to do, but I'm not sure if I'm doing it correctly.

[weaknessforcats]

This code:

test.data1 = malloc(sizeof(int));   // single int

does not allocate an int. All it allocates is the size of an int. Since test.data1 is a void* all you have is an address.

To use it you would need to cast the pointer to the correct type and then you can use the memory for a variable of that type.

BUT: Since it's a void* you have lost the size of the allocation. Now you have no idea how much memory the allocation has and there is no way to find out.

So when you typecast the pointer to some type you have no idea of the allocation will hold a value of that type.

A void* is one of the biggest problem areas in C and is the reason you don't use these things in C++.

[divideby0]

eek; that doesn't sound good.

Thank you so much for the comments. I'm trying to learn the language on my own and this bit is bizarre.

Do you mean that the void* cannot be used by itself with malloc? I tried a few malloc variations using gcc 4 with warnings treated as errors.

void *test = NULL;
 
(int *)test = malloc(...) <- lvalue error
 
test = malloc(sizeof((int *)test); appeared ok
*((int *)test) = 10;
 
test = malloc(sizeof(*((int *)test)); appeared ok
*((int *)test) = 10;
 

With the size being lost, wouldn't these have crashed?

[weaknessforcats]

This code:

void *test = NULL;
 
  (int *)test = malloc(...) <- lvalue error
 

won't compie because you are assigning a void* to an int*. You can assign an int* to a void* but not the other way around.

This code:

void *test = NULL;
 
 test = malloc(sizeof((int *)test); appeared ok
 *((int *)test) = 10;
 

You are allocating the size of an int address.

Then you assign the void* from malloc to a void* test. That's OK.

Then you cast a void* to an int*, dereference the int* and assign an int value. WARNING: You allocated the size of an address and not the size of an int. This works as long as the int value is the same size (or smaller) than an int address.

This code:

void *test = NULL;
  test = malloc(sizeof(*((int *)test)); appeared ok
  *((int *)test) = 10;
 

allocates the size of an int. Then the void* from malloc is assigned to the void* test. That's OK.

Then the void* test is cast to an int*. That's OK.
Then the int* test is dereferenced to an int and an int value assigned. That's OK.

Just look at these things the way the compiler would look at it.

[divideby0]

Thank you so much for the detailed explanation - it really helped. I appreciate your time.