When the compiler sees a string literal, what happens is something like this.
Code:
static const char __compiler_makes_up_a_unique_name__[] = "-1 -i 1200 -f";
This is what actually allocates the space for your string, and is initialised with your string.
Which transforms your code to
Code:
char *option = __compiler_makes_up_a_unique_name__;
file_write(option);
By way of an actual example
Code:
$ cat foo.c
void foo () {
char *option = "-1 -i 1200 -f";
file_write(option);
}
$ gcc -S foo.c
$ cat foo.s
.file "foo.c"
.text
.section .rodata
.LC0:
.string "-1 -i 1200 -f"
.text
.globl foo
.type foo, @function
foo:
.LFB0:
.cfi_startproc
endbr64
pushq %rbp
.cfi_def_cfa_offset 16
.cfi_offset 6, -16
movq %rsp, %rbp
.cfi_def_cfa_register 6
leaq .LC0(%rip), %rax
movq %rax, -8(%rbp)
// snipped for brevity
At line 10, the compiler made up the name ".LC0", and allocated and initialised it's contents with your string (using the assembler .string directive).
Line 24 loads the address of your string (aka the address of the symbol it generated for it), and line 25 is storing that address in your local variable 'option'.
> can the memory be intact in calling functions.
String constants exist for the life of the program (they have global scope).
Even when say the 'option' variable has gone out of scope, the actual bytes representing your string still exist.
So it's safe for a called function to make a copy of that pointer and it would still work.
This on the other hand is NOT the same thing.
Code:
void foo ( ) {
const char option[] = "-1 -i 1200 -f";
file_write(option);
}
file_write needs to completely process the string before it returns.
This would be a BAD file_write
Code:
const char *buffer[10];
int index = 0;
// save strings until the buffer is full, then write them all.
void file_write(const char *s) {
buffer[index++] = s;
}
Whilst it could work with the former, it definitely won't work with the latter.
