What is the difference between strcpy and strncpy?

Answer 1

strcpy - copy a string to a location YOU created (you create the location, make sure that the source string will have enough room there and afterwards use strcpy to copy)

strdup - copy a string to a location that will be created by the function. The function will allocate space, make sure that your string will fit there and copy the string. Will return a pointer to the created area.

Answer 2

memcpy will copy NULL bytes also, but strcpy will stop copying if it encounters NULL Byte, since it consider NULL as a terminating character.

cheers,

som shekhar

And another thing is if we want to copy two integer arrays or some other memory which are not strings we can use memcpy. strcpy/strncpy can be used for integer copies after typecasting but the behavior is unpridictable.

Strcpy usually accepts the char* as an argument but the memcpy accepts the void * as an argument.

-------Ravi

Answer 3

strcpy copies the entire string including the byte with the zero value that is the terminal character of a string.

strncpy copies at most n character or up to and including byte with the zero value is the string length is less than n.

If only n characters are copied the string will not always be zero terminated, be warned overlooking this fact is a quick way to a crash.

Answer 4

The best way to understand how any function works is to look at the implementation.

strcmp()

Here is the implementation for the strcmp function in C:

int strcmp (const char* s1, const char* s2) {

while (*s1 && (*s1==*s2)) s1++,s2++;

return *(const unsigned char*)s1-*(const unsigned char*)s2;

}

Despite its small size, there's quite a lot going on here. From the function prototype we can see that the function accepts two pointers to const char and returns an int.

The function body has a while loop which increments the pointers (s1++, s2++) so long as the following boolean expression holds true:

*s1 && (*s1==*s2)

The && is a logical AND and this has two operands, each of which is also a boolean expression.

The expression *s1 dereferences the value being pointed at by s1. That is; the expression evaluates the character code. If the code is zero then the expression evaluates false, otherwise it evaluates true.

The expression (*s1==*s2) dereferences the values pointed at by s1 and s2 and compares them for equality. If they are not equal, the expression evaluates false, otherwise it evaluates true.

For the whole expression to evaluate true, both operands must evaluate true. Note that if the first evaluates false then there is no need to evaluate the second; the entire expression is false regardless of whether the second is true or false.

From this we can see that s1 and s2 will iteratively advance through the characters in their respective strings until either s1 points to null or the two characters differ in some way.

The final line looks more complex than it really is; it simply returns the difference between the two character codes currently being pointed at. The explicit casts to const unsigned char are necessary because the C-standard does not define a "plain" char to be signed or unsigned (it is implementation-defined).

If the difference is zero then it means both s1 and s2 point to null terminators. It therefore follows that any and all of preceding characters matched exactly, thus the strings are the same. If the difference is non-zero, then the strings are not the same. If the difference is negative, the first string is lexicographically "less than" the second, otherwise it is "greater than".

The implementation also tells us that the function has undefined behaviour when either string is not null-terminated.

strcpy()

The strcpy function has the following implementation:

void strcpy (char* dst, const char* src) {

while ((*dst=*src)!='\0') dst++, src++;

}

Here we can see that the character pointed to by src is assigned to the memory pointed to by dst and the pointers advanced by one character. This repeats until the last copied character was a null-terminator ('\0'). Note that (*dst=*src) evaluates to the value of *dst after assignment and that this value can be used as the left-hand operand of the binary not-equal operator (!=).

From the implementation we can also see that the function has undefined behaviour when the source string is not null-terminated or the destination array is not large enough to cater for the source string.