I am trying to copy from a character array to character pointer. My code:
char str[] = "Hello World";
char *result = (char *)malloc(strlen(str)+1);
int index=0;
while(index <= strlen(str))
{
*result = str[index];
result++;
index++;
}
This above code is not working and below code is working
char str[] = "Hello World";
char *result = (char *)malloc(strlen(str)+1);
int index=0;
while(index <= strlen(str))
{
result[index] = str[index];
index++;
}
Can anyone explain this behavior?
we simply use the strcpy function to copy the array into the pointer.
char str[] = "Hello World";
char *result = (char *)malloc(strlen(str)+1);
strcpy(result,str);
In your first snippet you modify the pointer in the loop, so after the loop it will no longer point to the same location returned by the malloc call.
Look at it this way, after the call to malloc the pointer and the memory look like this:
result | v +---+---+---+---+---+---+---+---+---+---+---+---+ | | | | | | | | | | | | | +---+---+---+---+---+---+---+---+---+---+---+---+
After the first iteration of the loop it will look like this:
result
|
v
+---+---+---+---+---+---+---+---+---+---+---+---+
| H | | | | | | | | | | | |
+---+---+---+---+---+---+---+---+---+---+---+---+
And after the loop is done it will look like this
result
|
v
+---+---+---+---+---+---+---+---+---+---+---+----+
| H | e | l | l | o | | W | o | r | l | d | \0 |
+---+---+---+---+---+---+---+---+---+---+---+----+
The copying is made, but the pointer no longer points to the original position.
[Note: Before the copying, the memory allocated by malloc will not be "empty" or initialized in any way, I just show it like that here for simplicity's sake.]
result pointer this way OP won't even be able to free it anymore; that's why most of the cases I prefer array notation, it's also more readableTry this code.. Use strcpy() function.
char str[] = "Hello World";
char *result = (char *)malloc(strlen(str)+1);
strcpy(result,str);
Already you allocate a memory for that pointer, so you can simply use the strcpy() function to copy the characters
strcpy(result,str);
str copied to result.
strncpy(). Here the whole array copied to the pointer, so we can simply use the strcpy() function.
malloc(strlen(str)+1) Therefore, strcpy is guaranteed to work correctly and not overflow the buffer. If a fixed size output buffer was being used, and the length of the input string was unknown, then strncpy would be a better choice.In my opinion, there is no practical reason to modify your pointers (like you do in the first snippet) when you can just add an offset (like you do in the second snippet). It just makes the code a little bit harder to get right.
For the first snippet, try saving the original result like this:
char *result = ...
char *start = result;
And after the loop, try printing start, instead of result. It should point to the newly copied string, like you expect.
Your first code snippet copied the string perfectly , but in this process you moved allocated character pointer. If it has to work save its initial value in some temporary pointer
char str[] = "Hello World";
char *result = (char *)malloc(strlen(str)+1);
char *tmp = result;
int index=0;
while(index <= strlen(str))
{
*result = str[index];
result++;
index++;
}
printf("%s\n", tmp);
resultthen you will see that it will work.index <= strlen(str)– 'less or equal' rather than 'less than'.strlenrepeatedly. It doesn't change, after all.\0; your resulting string is an unterminated string. This might lead to undefined behavior in subsequent code.<=is correct here, but you should explain why. (You need the copy the last\0as well)