Suppose, I wrote a function as follows:
void foo()
{
char *strArr[] = {"AA", "BB", "CC"};
...
}
Where the strArr will be allocated? When will it be initialized?
For some reason I remember that such an array will be allocated in static memory space, not on the stack and initialized at the program start, as if I would write "static" before it. Is it a fake memory?
It has automatic storage so it will be allocated on the stack of the function. The elements belong to this automatic storage but the string literals themselves are stored in a persistent, possibly read-only area.
The array will be allocated as a local object. In general case, the memory for all local objects can be allocated early, when function begins execution, or it can be allocated "on demand", as control enters the nested blocks with object declarations. The language does not specify the exact moment.
In your specific example the memory for the array will be allocated when the function begins execution, since your array is declared in the "primary" block of the function.
As for initialization... In C89/90 version of C all aggregate initializers have to be constant expressions, which means that the aggregate initialization process cannot depend on any run-time values. Initilization can be hardcoded into the compiled program and can take place immediately after the array is allocated.
In C99 you can use run-time values in aggregate initializers, which means that the actual intialization might have to be delayed to the point when control passes over the declaration.
In your example the array is initialized with constant expressions, meaning that it can be initailized immediately after allocation. The compiler can actually prepare a static copy of your array in advance and simply "paste" it into stack every time the control enters the function.
P.S. Your references to "static memory" actually apply to string literals (like "AA") that you use to initialize the elements of your array. String literals indeed reside in static memory. However, string literals are completely independent objects, and your strArr array is a completely independent object.
Note, that you don't really have a "string array" in your example. What you have is an array of pointers to strings. Your strArr lives in local memory, while strings (to which elements of strArr point) live in static memory.
I just disassembled a sample program.
#include <stdio.h>
void foo()
{
char *strArr[] = {"AA", "BB", "CC"};
}
int main()
{
foo();
return 0;
}
It seems, string literals will be allocated in .rodata section.
.file "sfsfs.c"
.section .rodata
.LC0:
.string "AA"
.LC1:
.string "BB"
.LC2:
.string "CC"
.text
.globl foo
.type foo, @function
foo:
.LFB0:
.cfi_startproc
pushq %rbp
.cfi_def_cfa_offset 16
.cfi_offset 6, -16
.....
.....
But strArr will be allocated in stack only. because it's auto nature.
