Static vs. Malloc

Question

What is the advantage of the static keyword in block scope vs. using malloc?

For example:

Function A:

f() {
    static int x = 7;
}

Function B:

f() {
    int *x = malloc(sizeof(int));
    if (x != NULL)
        *x = 7;
}

If I am understanding this correctly, both programs create an integer 7 that is stored on the heap. In A, the variable is created at the very beginning in some permanent storage, before the main method executes. In B, you are allocating the memory on the spot once the function is called and then storing a 7 where that pointer points. In what type of situations might you use one method over the other? I know that you cannot free the x in function A, so wouldn't that make B generally more preferable?

Answer 1

consider below exaple to understand how static works. Generally we use static keyword to define scope of variable or function. e.g. a variable defined as static will be restricted within the function and will retail its value.

But as shown in below sample program if you pass the reference of the static variable to any other function you can still update the same variable from any other function.

But precisely the static variable dies when the program terminates, it means the memory will be freed.

#include <stdio.h>

void f2(int *j)
{
    (*j)++;
    printf("%d\n", *j);
}

void f1()
{   
    static int i = 10;
    printf("%d\n", i);
    f2(&i);
    printf("%d\n", i);  
}

int main()
{
    f1();       
    return 0;   
}

But in case of malloc(), memory will not be freed on termination of the program unless and untill programmer takes care of freeing the memory using free() before termination of the program.

This way you will feel that using malloc() we can have control over variable lifespan but beware...you have to be very precise in allocating and freeing the memory when you choose dynamic memory allocation. If you forget to free the memory and program terminated that part of heap cannot be used to allocate memory by other process. This will probably lead to starvation of memory in real world and slows down the computation. To come out of such situation you have to manually reboot the system.

Answer 2

First things first , static is a storage class , and malloc() is an API , which triggers the brk() system call to allocate memory on the heap.

If I am understanding this correctly, both programs create an integer 7 that is stored on the heap ?

No.Static variables are stored in the data section of the memory allocated to the program. Even though if the scope of a static variable ends , it can still be accessed outside its scope , this may indicate that , the contents of data segment , has a lifetime independent of scope.

In what type of situations might you use one method over the other?

If you want more control , within a given scope ,over your memory use malloc()/free(), else the simpler (and more cleaner) way is to use static.

In terms of performance , declaring a variable static is much faster , than allocating it on the heap . since the algorithms for heap management is complex and the time needed to service a heap request varies depending on the type of algorithm

One more reason i can think of suggesting static is that , the static variables are by default initialized to zero , so one more less thing to worry about.

Answer 3

If I am understanding this correctly, both programs create an integer 7 that is stored on the heap

No, static variables are created in Data or BSS segment, and they have lifetime throughout the lifetime of the program. When you alloc using malloc(), memory is allocated in heap, and they must be explicitly freed using free() call.

In what type of situations might you use one method over the other?

Well, you use the first method, when you want access to the same variable for the multiple invocation of the same function. ie, in your example, x will only initialized once, and when you call the method for the second time, the same x variable is used.

Second method can be used, when you don't want to share the variable for multiple invocation of the function, so that this function is called for the second time, x is malloced again. You must free x every time.

You can see the difference by calling f() 2 times, for each kind of f()

...
f();
f();
...

f(){
    static int x = 7;
    printf("x is : %d", x++);
}

f(){
   int *x = malloc(sizeof(int));
   if (x != NULL)
      *x = 7; 
   printf("x is : %d", (*x)++);
   free(x);   //never forget this,
}

the results will be different

Answer 4

Both programs create an integer 7 that is stored on the heap

No, they don't.
static creates a object with static storage duration which remains alive throughout the lifetime of the program. While a dynamically allocated object(created by malloc) remains in memory until explicitly deleted by free. Both provide distinct functionality. static maintains the state of the object within function calls while dynamically allocated object does not.

In what type of situations might you use one method over the other?

You use static when you want the object to be alive throughout the lifetime of program and maintain its state within function calls. If you are working in a multithreaded environment the same static object will be shared for all the threads and hence would need synchronization.

You use malloc when you explicitly want to control the lifetime of the object.for e.g: Making sure the object lives long enough till caller of function accesses it after the function call.(An automatic/local object will be deallocated once the scope{ } of the function ends). Unless the caller explicitly calls free the allocated memory is leaked until the OS reclaims it at program exit.

Answer 5

Read http://www.teigfam.net/oyvind/pub/notes/09_ANSI_C_static_vs_malloc.html

The static variable is created before main() and memory does not need to be allocated after running the program.

Answer 6

Forget stack v. heap. That is not the most important thing that is going on here.

Sometimes static modifies scope and sometimes it modifies lifetime. Prototypical example:

void int foo() {
     static int count = 0;
     return count++;
}

Try calling this repeatedly, perhaps from several different functions or files even, and you'll see that count keeps increasing, because in this case static gives the variable a lifetime equal to that of the entire execution of the program.

Answer 7

In Function A, you're allocating x with static storage duration, which generally means it is not on (what most people recognize as) the heap. Rather, it's just memory that's guaranteed to exist the entire time your program is running.

In Function B, you're allocating the storage every time you enter the function, and then (unless there's a free you haven't shown) leaking that memory.

Given only those two choices, Function A is clearly preferable. It has shortcomings (especially in the face of multi-threading) but at least there are some circumstances under which it's correct. Function B (as it stands) is just plain wrong.