Returning a struct pointer

Question

Suppose I have the following struct and function returning a pointer:

typedef struct {   int num;   void *nums;   int size; } Mystruct;  Mystruct *mystruct(int num, int size) {     //Is the following correct? Is there a more efficient way?    Mystruct mystruct;    mystruct.num = num;    mystruct.size = size;    mystruct.nums = malloc(num*sizeof(size));    Mystruct *my;    *my = mystruct;    return my; } 

I want to define any Mystruct pointer using the above function. Should I declare a Mystruct variable, define the properties of Mystruct, assign a pointer to it, and return the pointer or define the properties of a mystruct property through a pointer immediately?

Answer 1

Should I declare a Mystruct variable, define the properties of Mystruct, assign a pointer to it, and return the pointer

Definitely not, because the variable defined in the function (in "auto" storage class) will disappear as the function exits, and you'll return a dangling pointer.

You could accept a pointer to a Mystruct (caller's responsibility to allocate that) and fill it in; or, you can use malloc to create a new one (caller's responsibility to free it when it's done). The second option at least lets you keep the function signature you seem to be keen on:

Mystruct *mystruct(int num, int size) {    Mystruct *p = malloc(sizeof(MyStruct));    ....    return p; } 

but it's often an inferior one -- since the caller has to have responsibilities anyway, may as well go with the first option and potentially gain performance (if the caller can use an auto-class instance because it knows the scope of use is bounded).

Answer 2

You can't use the variable because it will be deallocated when the function exits. For example:

Mystruct *mystruct(int num, int size) {    MyStruct x;    x.num = 1;    ...    return &x; } 

Will give a segmentation fault or access violation because the memory for x is deallocated as soon as you exit. So you have to allocate memory for the struct (and be sure to free it up later) or declare a global that will stay around for ever. Example for the latter...

Mystruct *mystruct(int num, int size) {    MyStruct *x;    x = (MyStruct*)malloc( sizeof( MyStruct ) );    x->num = 1;    ...    return x; }