Some people seem to think that C's strcpy()
function is bad or evil. While I admit that it's usually better to use strncpy()
in order to avoid buffer overflows, the following (an implementation of the strdup()
function for those not lucky enough to have it) safely uses strcpy()
and should never overflow:
char *strdup(const char *s1)
{
char *s2 = malloc(strlen(s1)+1);
if(s2 == NULL)
{
return NULL;
}
strcpy(s2, s1);
return s2;
}
*s2
is guaranteed to have enough space to store *s1
, and using strcpy()
saves us from having to store the strlen()
result in another function to use later as the unnecessary (in this case) length parameter to strncpy()
. Yet some people write this function with strncpy()
, or even memcpy()
, which both require a length parameter. I would like to know what people think about this. If you think strcpy()
is safe in certain situations, say so. If you have a good reason not to use strcpy()
in this situation, please give it - I'd like to know why it might be better to use strncpy()
or memcpy()
in situations like this. If you think strcpy()
is okay, but not here, please explain.
Basically, I just want to know why some people use memcpy()
when others use strcpy()
and still others use plain strncpy()
. Is there any logic to preferring one over the three (disregarding the buffer checks of the first two)?
memcpy
can be faster than strcpy
and strncpy
because it does not have to compare each copied byte with '\0', and because it already knows the length of the copied object. It can be implemented in a similar way with the Duff's device, or use assembler instructions that copy several bytes at a time, like movsw and movsd