Thread: string declaration and memory leak?

Code:

char string1[255]="Hello world";

"Hello world" is string literal that is located somewhere in the read-only memory

string1 is character array of 255 bytes allocated on stack

after allocation of the memory the string "Hello world" is copied in the beginning of the allocated memory.

The rest of the buffer is available for use by the application later. for exmple

Code:

strcat(string1," from me on this sunny day!");

Originally Posted by ignazioc

thanks for your answer now it is clear but what's appen when i use

Code:

char string1[] = "hello world";
char *string2 = "hello world";

now there isn't array allocation, but there is only one single pointer...there isn't space for coping string-literal...maybe the compiler is so smart to allocating space automatically?

Incorrect. You appear to be making the mistake of believing that a pointer and an array are the same things. You also appear to believe that string2 becomes a synonym for string1: it is not.

string1 is initialised (and sized at compile tiime) using a literal "hello world". The contents of string1 may be modified, but the array cannot be resized. So modification of a character in string1 (for example, string1[4] = 'O' to change the first 'o' from lower case to upper case) is valid. But accessing an element past the end (for example, string1[20] = 'x') gives undefined behaviour - string1 cannot be resized at run time.

string2 is a pointer that is initialised so it points at the first character of a string literal "hello world". Any modification of that string literal using the pointer (for example, string2[4] = 'O' to change the first 'o' to 'O') gives undefined behaviour. A lot of compilers will warn about such things (as they can detect string2[4] should not be modified) but they are not required to.

Importantly, modifying string1 (for example, string1[4] = 'O') does not modify the string literal pointed to by string2 (unless the compiler is broken, and unfortunately some such compilers exist). Because of the existence of broken compilers (or, more accurately, over-aggressive optimisers) disciplined programmers will change your definition of string2 to

Code:

   const char *string2 = "hello world";

which FORCES the compiler to complain about any attempt to modify the literal (so string2[4] = 'O' will yield a compilation error).

Some compilers are are able to optimise usage of string literals. For example, in your code, they can detect there are two string literals with the same contents ("hello world") and rationalise that down to one instance of the data in memory. However, if the compiler does that, it is still required to allow string1 to be modifiable, it is still undefined behaviour to modify string2, and modifying string1 does NOT modify (your original) string2.