I have two programs written in C. Why does the first program work without malloc, but the second one doesn't unless I use malloc?
Code:int main(){ char * word; word = "abcde"; printf("You entered: %s\n", word ); }
Code:int main(){ char * word; strcpy(word, "abcde"); printf("You entered: %s\n", word ); }
"abcde" exists in memory in both programs as a string literal.
In the first program you are making the 'word' pointer point at "abcde" (or the address at which it resides). Nothing wrong with this, just know that you can't modify the string because it's in read only memory.
In the second program you are trying to copy "abcde" in to the memory pointed to by the 'word' pointer. You haven't initialised the 'word' pointer so it's pointing at some garbage value and you aren't allowed to write there.
malloc will create some memory for you to use for your 'word' pointer, thus allowing you to copy the string into it.
Thank you for the quick and helpful answer.
In the first bit, where you say
word = "abcde";
"abcde" exists. When you declare that literal, memory is reserved for it. Think of when you call printf. You give it a string literal, so what's actually happening is: memory is reserved, the string literal is placed there, and printf gets a pointer to it. So the point is: making a string literal reserves memory in an implicit way.
When you use strcopy, it modifies the memory where word points to. If you recall the pointer basics, word can point anywhere at all. Unfortunately for you, there is no rule that says it has to point somewhere that's yours. The memory it points to could be in use, by some other program or something. Making a pointer does not reserve memory. You have to direct to reserved memory. So if you set it equal to a string literal, it points to the literal which has it's own reserved memory, but by actually copying it, you are not changing where the pointer points, but rather moving the memory to the place. It's like instead of pointing at a lighthouse, you move the lighthouse in front of your finger.
If you really want to mix things up, try this.
This code attempts to modify the string literal "ABCDE", and then print it.Code:#include <string.h> #include <stdio.h> int main() { char *word; word = "ABCDCE"; strcpy(word, "abcde"); printf("You entered: %s\n", word ); }
Note that I've #include'd headers to prevent the compiler from applying default assumptions about what strcpy() and printf() do (and to prevent warnings from modern compilers).
The result is undefined. Modifying a string literal is actually not permitted. However, with most C compilers, it will compile - and possibly crash when executed. Some C compilers will give a warning (about the assignment "word = "ABCDE"") but most won't. With C++ compilers, the code is more likely to elicit a warning, since the conversion (of a string literal to a non-const char pointer) is deprecated.
To make your second program work without malloc, you can write it like this:Originally Posted by username1
The 6 means that 6 bytes are allocated at compile time, which is enough to hold strings which have a strlen of 5 or less.Code:int main(){ char word[6]; strcpy(word, "abcde"); printf("You entered: %s\n", word ); }
Quite often, the number 6 (N) is known, but you don't know how big the strings will be. Then it's better to use strncpy to avoid undefined behavior.
With strncpy, the character at position N-1 is guaranteed to be '\0' if the string "fits". Therefore, if it is not '\0' you know that it was too big.Code:#define WORD argv[1] #define N 6 int main(int argc, char *argv[]){ if (argc != 2) { printf("Usage: printword WORD\n"); exit(EXIT_SUCCESS); } char word[N]; if (strncpy(word, WORD, N)[N-1] != '\0') { printf("Sorry, that word is too long. Program will abort.\n"); exit(EXIT_FAILURE); } printf("You entered: %s\n", word); exit(EXIT_SUCCESS); }
