Reply to thread

Message: [QUOTE="Chris Torek, post: 1704867"] Right. When it is not an array initializer, it always produces an anonymous array. This array has "static duration" -- meaning it is valid during the entire execution of the program -- and may or may not reside in physically-read-only storage. If it is physically read-only, attempts to change it will fail: char *p = "mellow"; *p = 'y'; may leave *p unchanged, and/or may trap at runtime. The effect is formally undefined, and a compiler may well get confused and *think* it changed even if it did not. It might even present you with conflicting evidence, showing that it has both changed and not changed: printf("*p is '%c'; p is '%s'\n", *p, p); might print: *p is 'y'; p is 'mellow' Here the compiler "knows" it just set *p to 'y', so it can replace *p with 'y' in the call to printf(); but printf's %s format reads what is really still there in read-only memory, which is an 'm'. No -- in this case, the two values stored in myString *must* be distinct and compare not equal. More specifically, after: char *p1 = "one such array"; char *p2 = "something different"; it must definitely be the case that p1 != p2. However, in: char *p3 = "we will see this again"; char *p4 = "we will see this again"; the compiler is allowed, but not required, to use a single array to hold both strings, so that p3==p4 and p3!=p4 are *both* allowed. Aside from the fact that the anonymous array is (at least in principle) read-only -- and of course anonymous (unnamed) -- these four string literals are just shorthand for: static char __compiler_string_number_000001[] = "one such array"; static char __compiler_string_number_000002[] = "something different"; static char __compiler_string_number_000003[] = "we will see this again"; char *p1 = __compiler_string_number_000001; char *p2 = __compiler_string_number_000002; char *p3 = __compiler_string_number_000003; Whether p4 is __compiler_string_number_000004 or __compiler_string_number_000003 again is up to the compiler. Asking whether p3==p4 is the same, in this case, as asking whether __compiler_string_number_000003 was re-used. It would make more sense if these were: static const char __compiler_string_number_000001[] = ... but the 1989 C standard left the type unqualified (non-"const") for backwards compatibility with all those C compilers that came before it, where there was no "const" keyword. Finally, in the original example, we had, in effect: p1 = "some string that ends with a specific word"; followed by: p2 = "specific word"; In this case, a compiler is allowed -- but again not required -- to act more or less as if we had written: static char __compiler_string_number_000042[] = "some string that ends with a specific word"; /* 1 2 3 4 */ /* 0123456789012345678901234567890123456789012 */ p1 = __compiler_string_number_000042; p2 = __compiler_string_number_000042 + 29; As you can see from the comment (assuming you are viewing this in a fixed-width font), the text "specific word" occurs at offset 29 within the string "some string that ends with a specific word". (This optimization turns out to be relatively easy to make -- one just needs to collect all strings, group them by size, and then "compare backwards" to see if any one string is an exact match for the end of any equal-length-or-longer string. This does not catch all possible matches due to the ability to embed '\0' characters in a string literal, but the algorithm can be augmented if desired. Note that counted-length strings, which are being discussed in a separate ongoing thread in comp.lang.c now, do not lend themselves as easily to this string-sharing technique. There are two main ways to do counted-length strings, one of which prohibits sharing entirely and the other of which affords even more opportunities for sharing, so that a simple tail-match algorithm is insufficient.) It remains in memory, because a static-duration array exists until the program exits (and maybe even after that; the C standard necessarily says nothing about what happens before and after a program runs). As for whether this memory is "wasted", ask yourself this question: if the memory containing the string were to be used for something else, how would it (a) get set up initially, and (b) get "restored" if the function in question were re-entered? For instance: void f(void) { char *s; s = "hello"; puts(s); s = "world"; puts(s); } void g(void) { f(); f(); } Each time f() is called, the strings "hello" and "world" must be copied to stdout (and a newline added after each, as puts() does). If the six bytes that hold {'h', 'e', 'l', 'l', 'o', '\0'} were ever replaced with another six bytes, who or what would put back the original h e l l o \0 sequence? Would that take code and/or data space in the program? Would it take *more* code and/or data space than you might save by overwriting the original string? [/QUOTE]

Verification