type casting void pointer and allocate memory

Question

I have two structures:

typedef struct abc {
  unsigned int pref;
  unsigned int port;
  char *aRecordIp;
    int index;
    int count;
}abc_t;

typedef struct xyz {
        abc_t *ab;
        int index;
        int count;
}xyz_t;

and I would like to achieve the following

int Lookup (char *lookup,void *handle) {

*handle = (xyz_t *)malloc(sizeof(xyz_t *));
handle->ab = (abc_t *) malloc(sizeof(abc_t *));
//

}

I am trying to typecast void pointer to xyz_t basically.

Is this correct?

`handle` is a void pointer, and has no type information, it is only an address in memory, so calling `handle->ab` will not work. — Colin Basnett, Sep 10 '13 at 21:42
Is there any particular reason why you can't just change `Lookup` to take a `xyz_t*` instead of a `void*`? — Dennis Meng, Sep 10 '13 at 21:46
I have to question the sanity of what is being done here. You're passing in a void* (generated from where?) to overwrite its memory with a new structure and then accessing it. What is the point of this? — Colin Basnett, Sep 10 '13 at 21:47
@cmbasnett and Dennis Meng : handle is passed from another stack and it is a void pointer, I thought I could typecast it and use it — android.developer, Sep 11 '13 at 05:54

score 1 · Answer 1 · answered Sep 10 '13 at 21:50

You are doing it wrong on multiple counts:

You're trying to set a variable handle->ab, but handle is a void *, not a structure type pointer.
You need to show your call, but there's likely to be problems — why do you think a void * argument is a good idea?
You want to allocate structures, so the sizeof() operands should be xyz_t and not xyz_t *; repeat for abc_t.

You should probably use:

int Lookup(const char *lookup, xyz_t **handle)
{
    ...
    *handle = (xyz_t *)malloc(sizeof(xyz_t));
    (*handle)->ab = (abc_t *)malloc(sizeof(abc_t));
    ...
}

Don't forget to check the result of malloc().

There are those who will castigate you for using casts on malloc(). I won't. When I learned C (a long time ago, years before there was a C standard), on a machine where the int * value for an address was not the same bit pattern as the char * address for the same memory location, where malloc() had to be declared char *malloc() or all hell broke loose, the casts were necessary. But — and this is the major issue that people are concerned about — it is crucial that you compile with compiler options such that if you invoke a function without a prototype in scope, you will get a compilation error, or a warning that you will pay attention to. The concern is that if you do not have a declaration for malloc() in scope, you will get incorrect results from using the cast which the compiler would diagnose if you don't.

On the whole, though, I think you should separate your lookup code from your 'create xyz_t' code — your function is doing two jobs and it complicates the interface to your function.

xyz_t *Create_xyz(void);
int Lookup(const char *lookup, const xyz_t *handle);

Is there a way where I could still keep the handle as void * and typecast it to xyz_t in Lookup() ? — android.developer, Sep 11 '13 at 05:56

score 0 · Answer 2 · edited May 23 '17 at 10:25

0

While casting of a void* to any pointer type is correct, it is not necessary in C, and it is not recommended for malloc (e.g. see Do I cast the result of malloc? ).

Also, you should specify sizeof(xyz_t), not sieof(xyz_t*), otherwise you allocate memory enough only for pointer, not for the whole structure.

And of course you should assign a pointer to handle, not to *handle. And handle should be of proper pointer type (xyz_t*).

Oh, and if the question is about casting handle to xyz_t*, then you can do it like ((xyz_t*)handle)->ab.

I'd recommend reading a book before playing with pointers like that.

edited May 23 '17 at 10:25

Community

1
1

answered Sep 10 '13 at 21:41

nullptr

11,008
1
23
18

Ok, when I try handle->ab , I get "error: request for member 'ab' in something not a structure or union", is it because of sizeof(xyz_t*) – android.developer Sep 10 '13 at 21:43
That's because you `handle` is `void*`. Declare it as `xyz_t*`, as it is actually. – nullptr Sep 10 '13 at 21:44
1

Probably it should be `xyz_t **` to be useful. – Carl Norum Sep 10 '13 at 21:45

score 0 · Answer 3 · answered Sep 10 '13 at 21:49

0

I believe you want handle to hold a valid address of a xyz_t struct after the function call. Then you need to change the function signature and contents like so:

int Lookup (char *lookup, xyz_t **handle) {  // double indirection here

    *handle = (xyz_t *)malloc(sizeof(xyz_t));
    (*handle)->ab = (abc_t *) malloc(sizeof(abc_t));
}

And call it like this:

xyz_t *myhandle;
char lookup;  
Lookup(&lookup, &mynandle);

// now you can use it
myhandle->index ...

You will need to free the memory as well...

free(myhandle->ab);
free(myhandle);

answered Sep 10 '13 at 21:49

Israel Unterman

13,158
4
28
35

Is there a way where I could still keep the handle as void * and typecast it to xyz_t in Lookup() ? – android.developer Sep 11 '13 at 05:56
What is the benefit, in your view, of keeping a `void *`? It is as type-unsafe as hell! – Jonathan Leffler Sep 11 '13 at 06:13
because the handle that is passed in is a void pointer. So here is the thing, if I keep the function as you have suggested how do I send a void *handle to it. Ex: I want to achieve something like this `void *myhandle;` `char lookup;` `Lookup(&lookup, &mynandle);` – android.developer Sep 11 '13 at 15:28

score 0 · Answer 4 · answered Sep 11 '13 at 16:18

0

If you want to pass void *, here is the solution

int Lookup (char *lookup, void *handle) {

handle = malloc(sizeof(xyz_t));
((xyz_t *)handle)->ab = (abc_t *) malloc(sizeof(abc_t));
//

}

answered Sep 11 '13 at 16:18

Vivek S

1,251
10
12

type casting void pointer and allocate memory

4 Answers4