What is the difference between memmove and memcpy?

memmove and memcpy are functions in the C programming language used for copying memory, defined in the <string.h> header file. However, their behavior differs when handling overlapping memory regions, which is their primary distinction.

memcpy Function

memcpy is used to copy the contents of one memory region to another. Its prototype is as follows:

c
void *memcpy(void *dest, const void *src, size_t n);

• dest is a pointer to the destination memory region.
• src is a pointer to the source memory region.
• n is the number of bytes to copy.

memcpy assumes that the source (src) and destination (dest) memory regions do not overlap, so its implementation typically copies data directly from the source to the destination. This assumption makes memcpy highly efficient when there is no overlap.

memmove Function

memmove is also used for copying memory, but it correctly handles overlapping memory regions. Its prototype is as follows:

c
void *memmove(void *dest, const void *src, size_t n);

• Parameters are the same as memcpy.

When memory regions overlap, memmove ensures the copy operation results in correct data. It typically achieves this by first copying the source data to a temporary buffer and then copying from the temporary buffer to the destination, or by using reverse copying to avoid directly overwriting data that has not yet been copied.

Usage Example

Consider the following example of overlapping memory:

c
char buffer[10] = "abcdefghi";

If we want to move the first three characters "abc" from the buffer to the last three positions to become "defabcghi", using memcpy will not yield the correct result because the data source is modified during the copy. In contrast, memmove handles this correctly:

c
memmove(buffer + 3, buffer, 3);  // Correct
memcpy(buffer + 3, buffer, 3);   // May be incorrect

Summary

In general, when you are unsure whether memory regions overlap or know that memory overlaps, using memmove is a safer choice. If you can ensure that memory regions do not overlap, memcpy may provide better performance. Which one to choose in specific implementation projects depends on the actual situation and performance requirements.