strcpy vs. memcpy

What is the difference between memcpy() and strcpy()? I tried to find it with the help of a program but both are giving the same output.

int main()
{
    char s[5]={'s','a','\0','c','h'};
    char p[5];
    char t[5];
    strcpy(p,s);
    memcpy(t,s,5);
    printf("sachin p is [%s], t is [%s]",p,t);
    return 0;
}

Output

sachin p is [sa], t is [sa]

> what could be done to see this effect

Compile and run this code:

void dump5(char *str);

int main()
{
    char s[5]={'s','a','\0','c','h'};

    char membuff[5]; 
    char strbuff[5];
	memset(membuff, 0, 5); // init both buffers to nulls
	memset(strbuff, 0, 5);

    strcpy(strbuff,s);
    memcpy(membuff,s,5);

	dump5(membuff); // show what happened
	dump5(strbuff);

	return 0;
}

void dump5(char *str)
{
	char *p = str;
	for (int n = 0; n < 5; ++n)
	{
	    printf("%2.2x ", *p);
	    ++p;
	}

	printf("\t");

	p = str;
	for (int n = 0; n < 5; ++n)
	{
	    printf("%c", *p ? *p : ' ');
	    ++p;
	}

	printf("\n", str);
}

It will produce this output:

73 61 00 63 68  sa ch
73 61 00 00 00  sa

You can see that the "ch" was copied by memcpy(), but not strcpy().

strcpy stops when it encounters a NUL ('\0') character, memcpy does not. You do not see the effect here, as %s in printf also stops at NUL.

strcpy terminates when the source string's null terminator is found. memcpy requires a size parameter be passed. In the case you presented the printf statement is halting after the null terminator is found for both character arrays, however you will find t[3] and t[4] have copied data in them as well.

strcpy copies character from source to destination one by one until it find NULL or '\0' character in the source.

while((*dst++) = (*src++));

where as memcpy copies data (not character) from source to destination of given size n, irrespective of data in source.

memcpy should be used if you know well that source contain other than character. for encrypted data or binary data, memcpy is ideal way to go.

strcpy is deprecated, so use strncpy.

The main difference is that memcpy() always copies the exact number of bytes you specify; strcpy(), on the other hand, will copy until it reads a NUL (aka 0) byte, and then stop after that.

Because of the null character in your s string, the printf won't show anything beyond that. The difference between p and t will be in characters 4 and 5. p won't have any (they'll be garbage) and t will have the 'c' and 'h'.

• Behavior difference: strcpy stops when it encounters a NULL or '\0'
• Performance difference: memcpy is usually more efficient than strcpy, which always scan the data it copies

The problem with your test-program is, that the printf() stops inserting the argument into %s, when it encounters a null-termination \0. So in your output you probably have not noticed, that memcpy() copied the characters c and h as well.

I have seen in GNU glibc-2.24, that (for x86) strcpy() just calls memcpy(dest, src, strlen(src) + 1).

printf("%s",...) stops printing the data when null is encountered, so both the outputs are same.

The following code differentiates between strcpy and memcpy:

#include<stdio.h>
#include<string.h>

int main()
{
    char s[5]={'s','a','\0','c','h'};
    char p[5];
    char t[5];
    int i;
    strcpy(p,s);
    memcpy(t,s,5);
    for(i=0;i<5;i++)
        printf("%c",p[i]);
        printf("\n");
    for(i=0;i<5;i++)
        printf("%c",t[i]);

    return 0;
}