Difference in creating a struct using malloc and without malloc

Question

Could someone please explain to me the difference between creating a structure with and without malloc. When should malloc be used and when should the regular initialization be used?

For example:

struct person {

    char* name;

};

struct person p = {.name="apple"};

struct person* p_tr = malloc(sizeof(struct person));
p_tr->name = "apple";

What is really the difference between the two? When would one approach be used over others?

Answer 1

Having a data structure like;

struct myStruct {
    int a;
    char *b;
};

struct myStruct p;  // alternative 1
struct myStruct *q = malloc(sizeof(struct myStruct));  // alternative 2

• Alternative 1: Allocates a myStruct width of memory space on stack and hands back to you the memory address of the struct (ie, &p gives you the first byte address of the struct). If it is declared in a function, its life ends when the function exits (ie if function gets out of the scope, you can't reach it).

• Alternative 2: Allocates a myStruct width of memory space on heap and a pointer width of memory space of type (struct myStruct*) on stack . The pointer value on the stack gets assigned the value of the memory address of the struct (which is on the heap) and this pointer address (not the actual struct s address) is handed back to you. It's life time never ends until you use free(q) .

In the latter case, say, myStruct sits on memory address 0xabcd0000 and q sits on memory address 0xdddd0000 ; then, the pointer value on memory address 0xdddd0000 is assigned as 0xabcd0000 and this is returned back to you.

printf("%p\n", &p); // will print "0xabcd0000" (the address of struct)

printf("%p\n", q);  // will print "0xabcd0000" (the address of struct)
printf("%p\n", &q); // will print "0xdddd0000" (the address of pointer)

Addressing the second part of your; when to use which:

• If this struct is in a function and you need to use it after the function exits, you need to malloc it. You can use the value of the struct by returning the pointer, like: return q; .
• If this struct is temporary and you do not need its value after, you do not need to malloc memory.

Usage with an example:

struct myStruct {
    int a;
    char *b;
};

struct myStruct *foo() {
    struct myStruct p;
    p.a = 5;
    return &p; // after this point, it's out of scope; possible warning
}

struct myStruct *bar() {
    struct myStruct *q = malloc(sizeof(struct myStruct));
    q->a = 5;
    return q;
}

int main() {
    struct myStruct *pMain = foo();
    // memory is allocated in foo. p.a was assigned as '5'.
    // a memory address is returned.
    // but be careful!!!
    // memory is susceptible to be overwritten.
    // it is out of your control.

    struct myStruct *qMain = bar();
    // memory is allocated in bar. q->a was assigned as '5'.
    // a memory address is returned.
    // memory is *not* susceptible to be overwritten
    // until you use 'free(qMain);'
}

Answer 2

If we assume both examples occur inside a function, then in:

struct person p = {.name="apple"};

the C implementation automatically allocates memory for p and releases it when execution of the function ends (or, if the statement is inside a block nested in the function, when execution of that block ends). This is useful when:

• You are working with objects of modest size. (For big objects, using many kibibytes of memory, malloc may be better. The thresholds vary depending on circumstances.)
• You are working with a small number of objects at one time.

In:

struct person* p_tr = malloc(sizeof(struct person));
p_tr->name = "apple";

the program explicitly requests memory for an object, and the program generally should release that memory with free when it is done with the object. This is useful when:

• The object must be returned to the caller of the function. An automatic object, as used above, will cease to exist (in the C model of computation; the actual memory in your computer does not stop existing—rather it is merely no longer reserved for use for the object) when execution of the function ends, but this allocated object will continue to exist until the program frees it (or ends execution).
• The object is very large. (Generally, C implementations provide more memory for allocation by malloc than they do for automatic objects.)
• The program will create a variable number of such objects, depending on circumstances, such as creating linked lists, trees, or other structures from input whose size is not known before it is read.

Note that struct person p = {.name="apple"}; initializes the name member with "apple" and initializes all other members to zero. However, the code that uses malloc and assigns to p_tr->name does not initialize the other members.

If struct person p = {.name="apple"}; appears outside of a function, then it creates an object with static storage duration. It will exist for the duration of program execution.

Instead of struct person* p_tr = malloc(sizeof(struct person)); , it is preferable to use struct person *p_tr = malloc(sizeof *p_tr); . With the former, a change to the p_tr requires edits in two places, which allows a human opportunity to make mistakes. With the latter, changing the type of p_tr in just one place will still result in the correct size being requested.

Answer 3

struct person p = {.name="apple"};

^This is Automatic allocation for a variable/instance of type person.

struct person* p_tr = malloc(sizeof(person));

^This is dynamic allocation for a variable/instance of type person.

Static memory allocation occurs at Compile Time. Dynamic memory allocation means it allocates memory at runtime when the program executes that line of instruction

Answer 4

Judging by your comments, you are interested in when to use one or the other. Note that all types of allocation reserve a computer memory sufficient to fit the value of the variable in it. The size depends on the type of the variable. Statically allocated variables are pined to a place in the memory by the compiler. Automatically allocated variables are pinned to a place in stack by the same compiler. Dynamically allocated variables do not exist before the program starts and do not have any place in memory till they are allocated by 'malloc' or other functions.

All named variables are allocated statically or automatically. Dynamic variables are allocated by the program, but in order to be able to access them, one still needs a named variable, which is a pointer. A pointer is a variable which is big enough to keep an address of another variable. The latter could be allocated dynamically or statically or automatically.

The question is, what to do if your program does not know the number of objects it needs to use during the execution time. For example, what if you read some data from a file and create a dynamic struct, like a list or a tree in your program. You do not know exactly how many members of such a struct you would have. This is the main use for the dynamically allocated variables. You can create as many of them as needed and put all on the list. In the simplest case you only need one named variable which points to the beginning of the list to know about all of the objects on the list.

Another interesting use is when you return a complex struct from a function. If allocated automatically on the stack, it will cease to exist after returning from the function. Dynamically allocated data will be persistent till it is explicitly freed. So, using the dynamic allocation would help here.

There are other uses as well.

In your simple example there is no much difference between both cases. The second requires additional computer operations, call to the 'malloc' function to allocate the memory for your struct. Whether in the first case the memory for the struct is allocated in a static program region defined at the program start up time. Note that the pointer in the second case also allocated statically. It just keeps the address of the memory region for the struct.

Also, as a general rule, the dynamically allocated data should be eventually freed by the 'free' function. You cannot free the static data.