Can I save (and use) char* literal passed to a function after it ends?

Question

I am trying to pass a literal to a function, assign it to struct and use it later. Do I have to malloc() and strcpy(), or can I save the char* for use later (does it get statically allocated or not)?

Minimalistic example code below:

struct data {
    char *string;
    ...;
}

struct data *create_data(char *input_string, ...) {
    struct data *result = malloc(sizeof(struct data));
    result->string = input_string;
    return result;
}

struct data *string = create_data("Hey", ...);
printf("%s", data->string);

or

struct data *create_data(char *input_string, ...) {
    struct data *result = malloc(sizeof(struct data));
    result->string = malloc(sizeof(input_string));
    strcpy(result->string, input_string);
    return result;
}

struct data *string = create_data("Hey",...);
printf("%s", data->string);

Can I expect the first one to work, so the data in memory wouldn't get overwritten, or is it unsafe to assume so?

Note that `sizeof data` is the size of *the pointer* and not what it points to. — Some programmer dude, May 04 '19 at 19:41
C11 draft standard n1570: *6.4.5 String literals 6 In translation phase 7, a byte or code of value zero is appended to each multibyte character sequence that results from a string literal or literals. 78) The multibyte character sequence is then used to initialize an array of static storage duration and length just sufficient to contain the sequence.[...]* — EOF, May 04 '19 at 19:43
@AnttiHaapala Not now, but there's still `sizeof(input_string)` which is the same. — Some programmer dude, May 04 '19 at 19:48
@MarosMacko If you want to get the length of a string the use `strlen` (and remember that is does not include the null-terminator). — Some programmer dude, May 04 '19 at 19:49
@Someprogrammerdude Appears to me that the size of the pointer is exactly what's needed here. (The name `data` is somewhat misleading, better would be `data_handle` or `charptr_wrapper` or such.) **Oh.** You are referring to the second example. I see. — Peter - Reinstate Monica, May 04 '19 at 19:57

Antti Haapala -- Слава Україні · Accepted Answer · 2019-05-04T20:02:09.557

The string literals have static storage duration. For such an object, C11 6.2.4p3 says that:

Its lifetime is the entire execution of the program and its stored value is initialized only once, prior to program startup.

And of lifetime C11 6.2.4p2

The lifetime of an object is the portion of program execution during which storage is guaranteed to be reserved for it. An object exists, has a constant address,33) and retains its last-stored value throughout its lifetime.34) If an object is referred to outside of its lifetime, the behavior is undefined. The value of a pointer becomes indeterminate when the object it points to (or just past) reaches the end of its lifetime.

I.e. you can safely store a pointer to a string literal for the remainder of program execution.

However, attempts to free a string literal will have undefined behaviour, so if you sometimes use a string literal and sometimes a mallocated string, you need to either keep track of it, or use your 2nd alternative for all cases.

And since string literals are immutable, you must copy them if you intend to modify the string.

Finally, malloc(sizeof(input_string)) is wrong, it must be malloc(strlen(input_string) + 1). For duplicating a string, POSIX has the strdup function.

Thanks a lot Antti! You connected all the dots for me. I would upvote if I could :D — Maros Macko, May 04 '19 at 19:57
If you're warning about possible misuses (like `free()`ing the pointer), you might want to warn against modifying the pointed-to array as well. — EOF, May 04 '19 at 19:58

Can I save (and use) char* literal passed to a function after it ends?

1 Answers1