Question

In a C runtime environment, which one of the following is stored in the heap?

• A. A static variable declared inside a function
• B. An array of integers declared inside a function
• C. A dynamically allocated array of integers created using a malloc() function call
• D. Return address of a function

Hint:

Only memory obtained through malloc() (or calloc/realloc) lives on the heap and must be freed explicitly; locals, return addresses go on the stack and statics live in the data segment.

Answer 1

The Correct Option is C

Step 1: A reliable way to tell which memory region something lives in is to ask two questions, who is responsible for freeing this memory, and when does it get freed. The answer sorts it into stack, static/data segment, or heap.

Step 2: For option (A), a static variable inside a function, nobody ever explicitly frees it, and it is not freed automatically at function-return time either, it simply exists as long as the whole program runs, then goes away when the program exits. That "lives for the entire program, no manual free" pattern is the static/data segment, not the heap.

Step 3: For option (B), a plain local array, it is freed automatically, and immediately, the moment the function returns. Nobody calls any explicit release function, the compiler-generated code simply pops the function's stack frame. Automatic release tied exactly to function return is the signature of the stack.

Step 4: For option (D), the return address, this is also freed automatically the instant the function returns, as part of popping that same stack frame, so it follows the identical stack pattern as option (B).

Step 5: For option (C), memory from malloc(), nothing releases it automatically when the allocating function returns, the programmer must explicitly call free() on it later, possibly from a completely different function, or it stays allocated for the rest of the program's run if never freed. This "must be explicitly and manually released, independent of any function returning" pattern is exactly how heap memory behaves, and it is the only option among the four that shows this pattern.

Step 6: Since only the malloc()-allocated array requires an explicit, separate free() call rather than being cleaned up automatically by scope or program exit, option (C) is the one stored in the heap.

\[ \boxed{\text{Option C: dynamically allocated array via malloc()}} \]