What's the difference between memcpy, memmove, and strncpy for copying data in C programming?

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

int main() {
    char src[19] = "abcdef";

    char *target = src;

    memcpy(target+3,target,5);
    printf("from memcpy  : %s\n", target);

    strncpy(target+3,target,5);
    printf("from strncpy : %s\n", target);

    memmove(target+3,target,5);
    printf("from memmove : %s\n", target);
}

from memcpy  : abcabcde
from strncpy : abcabcab
from memmove : abcabcab

i see different function names but the usage is the same i have searching on google microsoft some of the developers say that is it deprecated and harmeful i want to understand which one of these functions is the right for copying data in c language ?

Simply:

1. memmove copies n bytes from src to dest.
2. memcpy copies n bytes from src to dest, as long as the two regions do not overlap.
3. strncpy copies n bytes, or up to a \0 byte, from src to dest, whichever comes first. (And as long as the two regions do not overlap.) Also it pads the destination out to n characters using \0, if necessary.

If you don't want to think about all this, just always use memmove. In particular (and as you can see by the length of my "simple" description of it with respect to the others), strncpy is too weird and complicated to be generally useful.

[Footnote: you didn't ask about strlcpy, but it's quite useful, and does what you probably wanted strncpy to do.]

To demonstrate the difference between strncpy and memcpy:

char a[] = "hello";
char b[] = "world";

strncpy(a, "pq
char a[] = "hello";
char b[] = "world";
strncpy(a, "pq\0rs", 5);
printf("after strncpy: a = %c %c %c %c %c = %s\n",
a[0], a[1], a[2], a[3], a[4], a);
memcpy(b, "pq\0rs", 5);
printf("after memcpy: b = %c %c %c %c %c = %s\n",
b[0], b[1], b[2], b[3], b[4], b);
rs", 5);

printf("after strncpy: a = %c %c %c %c %c = %s\n",
            a[0], a[1], a[2], a[3], a[4], a);

memcpy(b, "pq
char a[] = "hello";
char b[] = "world";
strncpy(a, "pq\0rs", 5);
printf("after strncpy: a = %c %c %c %c %c = %s\n",
a[0], a[1], a[2], a[3], a[4], a);
memcpy(b, "pq\0rs", 5);
printf("after memcpy: b = %c %c %c %c %c = %s\n",
b[0], b[1], b[2], b[3], b[4], b);
rs", 5);

printf("after memcpy: b = %c %c %c %c %c = %s\n",
            b[0], b[1], b[2], b[3], b[4], b);

This prints

after strncpy: a = p q      = pq
after memcpy:  b = p q  r s = pq

Notice that memcpy copied everything, while strncpy only copied the first two characters p and q, and then zeroed out the rest.

Most of the time, the source and destination regions do not overlap. Here's an example where they do:

char x[] = "abcdefghi";
memmove(&x[3], &x[0], 6);
printf("after memmove: %s\n", x);

char y[] = "abcdefghi";
memcpy(&y[3], &y[0], 6);
printf("after memcpy:  %s\n", y);

On my machine this prints:

after memmove: abcabcdef
after memcpy:  abcabcdbc

This code fragment tries to copy the first 6 characters of the string on top of the last 6 copies of the string. Using memmove, this works, resulting in abcabcdef. But using memcpy, we get a wrong result, because by the time it tries to copy the def, they have already been overwritten by abc. (Actually it's a bit more complicated than that, but hopefully you get the idea.)

memcpy and memmove operate dependently AND independently of data type. From the Linux man pages:

> The memcpy() function copies n bytes from memory area src to memory area dest. The memory areas must not overlap. Use memmove(3) if the memory areas do overlap.

To address my apparent contradiction: if I have int2, that is 8 bytes (assuming we're not on an old 16-bit system where int is 2 bytes). Note what happens when I try to copy 1 int:

char hex(char num) {
	if(num >=0 && num < 10) {
		return '0' + num;
	} else if(num > 9 && num < 16) {
		return (num - 10) + 'a';
	} else {
		return '
char hex(char num) {
if(num >=0 && num < 10) {
return '0' + num;
} else if(num > 9 && num < 16) {
return (num - 10) + 'a';
} else {
return '\0';
}
}
void dump(void *ptr) {
// assume 8 bytes
for(int i = 0; i<8; i++) {
char* byte = (char *) (ptr + i);
char high_nibble = (*byte & 0xf0) >> 4;
char low_nibble = *byte & 0x0f;
cout << hex(high_nibble) << hex(low_nibble) << "    ";
}
cout << endl;
}
int main() {
int num[2] = {123456, 65536};
dump(&num);
memcpy(num, num + 1, 1);
dump(&num);
}
';
	}
}

void dump(void *ptr) {
	// assume 8 bytes
	for(int i = 0; i<8; i++) {
		char* byte = (char *) (ptr + i);
		char high_nibble = (*byte & 0xf0) >> 4;
		char low_nibble = *byte & 0x0f;
		cout << hex(high_nibble) << hex(low_nibble) << "    ";
	}
	cout << endl;
}

int main() {
	int num[2] = {123456, 65536};
	dump(&num);
	memcpy(num, num + 1, 1);
	dump(&num);
}

The result is:

What happened? When we offset the pointer by 1 (2nd parameter of memcpy), it pointed to the next int, but when we specified "1" to be copied, it copied 1 byte rather than 1 int. We must specify sizeof(int) as our number of bytes to copy:

	memcpy(num, num + 1, sizeof(int));

Now we get what we need:

memcpy does not allow src and dest to overlap.

strncpy is like memcpy but for strings, and if a null character ('\0') is encountered before the number of specified bytes is encountered, the copy ends.