将char的c字符串char复制到动态char *

Question

I have a const char* string, I want to copy that string character by character to dynamic `char*.

const char *constStr = "Hello world";
char *str = (char*) malloc(strlen(constStr)+1);
while(*constStr){
   *str = *constStr;
   constStr++;
   str++;
}
printf("%s", str);
free(str);

The problem is that previous code just copies each character of constStr to only the first index of the str . I don't know why?

Answer 1

As others have pointed out, you are incrementing str pointer in each iteration, so you always end up printing the end of the string.

You can instead iterate over each character without incrementing the pointer. The following code worked for me:

const char *constStr = "Hello world";
int len = strlen(constStr);
char *str = (char *) malloc(len + 1);
int i;
for (i = 0; i <= len; ++i) {
    str[i] = constStr[i];
}
printf("%s", str);
free(str);

Answer 2

Yes you didn't null terminate the string. That was the primary problem. To be more clear, it is not that you didn't nul terminate the string which is the problem but rather your use of them where a pointer to a nul terminated char array is expected is the problem. But even if you did there was significant amount of problems in the code.

You allocated the memory and the casted the return value of malloc which is unnecessary. void* to char* conversion is implicitly done.

malloc might not be able to service the request, it might return a null pointer. It is important to check for this to prevent later attempts to dereference the null pointer.

Then you started copying - you copied everything except the NUL terminating character. And then you passed it to printf 's %s format specifier which expects a pointer to a null terminated char array. This is undefined behavior.

The one position, in the str is uninitialized - beware that accessing uninitialized value may lead to undefined behavior.

Also there is another problem, From standard § 7.22.3.3

The free function causes the space pointed to by ptr to be deallocated, that is, made available for further allocation. If ptr is a null pointer, no action occurs. Otherwise, if the argument does not match a pointer earlier returned by a memory management function , or if the space has been deallocated by a call to free or realloc, the behavior is undefined .

Yes so is is the case here? No. when you called free(str) str is not pointing to the dynamically allocated memory returned by the malloc . This is again undefined behavior.

The solution always is to keep a pointer which stores the address of the allocated chunk. The other answers already showed them (without repeating them - both of them provides a good solution).

You can use strdup or strcpy also - even if you don't need them now - get accustomed with them. It helps to know those. And yes strdup is not part of standard, it is a POSIX standard thing.

Example:

const char *constStr = "Hello world";
char *str = malloc(strlen(constStr)+1);
if( !str ){
    perror("malloc");
    exit(EXIT_FAILURE);
}
char *sstr = str;
while(*constStr){
   *str = *constStr;
   constStr++;
   str++;
}
*str = 0;
printf("%s", sstr);
free(sstr);

Answer 3

Here's the "classical" string copy solution:

const char *constStr = "Hello world";
char *str = malloc(strlen(constStr) + 1), *p = str;
/* Do not forget to check if str!=NULL !*/
while((*p++ = *constStr++));
puts(str);

Answer 4

The problem is that previous code just copies each character of constStr to only the first index of the str. I don't know why?

1. Use index variable.
2. Don't forget terminating '\\0' because you have a good chance of segmentation fault.