When should I use memcpy and when should I use memmove?

memcpy vs. memmove: Understanding Memory Copy Operations in C/C++

Explore the critical differences between memcpy and memmove in C/C++, focusing on their behavior with overlapping memory regions and when to use each for safe and efficient memory manipulation.

In C and C++, manipulating raw memory is a common task, especially when dealing with low-level data structures or performance-critical applications. Two fundamental functions provided by the standard library for copying blocks of memory are memcpy and memmove. While they both serve the purpose of copying data from a source to a destination, their behavior differs significantly when the source and destination memory regions overlap. Understanding this distinction is crucial for preventing subtle bugs and ensuring the correctness of your programs.

Understanding memcpy

The memcpy function is designed for speed and efficiency when copying data between non-overlapping memory regions. It copies n bytes from the memory area pointed to by src to the memory area pointed to by dest. The function signature is typically:

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

Key characteristics of memcpy:

• Undefined Behavior on Overlap: If the source and destination memory regions overlap, the behavior of memcpy is undefined. This means the result could be anything from a corrupted copy to a program crash, depending on the compiler, platform, and specific overlap pattern.
• Optimized for Speed: Because it assumes non-overlapping regions, memcpy implementations can be highly optimized, often leveraging processor-specific instructions (like SSE or AVX on x86) for very fast byte-by-byte or word-by-word copying.
• No Guarantee of Copy Order: The standard does not specify the order in which bytes are copied. An implementation might copy from left-to-right, right-to-left, or even in parallel, as long as the regions don't overlap.

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

int main() {
    char source[] = "Hello, World!";
    char destination[20];

    // Safe use of memcpy with non-overlapping regions
    memcpy(destination, source, strlen(source) + 1);
    printf("Destination: %s\n", destination);

    // Example of undefined behavior with overlapping regions (DO NOT DO THIS!)
    // char buffer[] = "abcdefgh";
    // memcpy(buffer + 1, buffer, 5); // Copies "abcde" to "bcdef"
    // printf("Buffer (overlapping memcpy): %s\n", buffer); // Output is unpredictable

    return 0;
}

Demonstrates safe usage of memcpy with non-overlapping buffers.

flowchart LR
    A[Start] --> B{Memory Regions Overlap?}
    B -->|No| C[Use memcpy]
    C --> D[Fast, Efficient Copy]
    B -->|Yes| E[Undefined Behavior]
    E --> F[Potential Data Corruption/Crash]
    D --> G[End]
    F --> G[End]

Decision flow for using memcpy.

Understanding memmove

The memmove function is designed to safely copy data between memory regions, even if they overlap. It also copies n bytes from src to dest. The function signature is identical to memcpy:

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

Key characteristics of memmove:

• Handles Overlapping Regions Safely: memmove guarantees that the copy will be performed correctly regardless of whether src and dest overlap. It achieves this by internally checking for overlap and adjusting its copy strategy.
• Slightly Slower (Potentially): To handle overlapping regions, memmove might perform an internal check and, if overlap is detected, copy bytes in a specific order (e.g., from left-to-right if dest < src or right-to-left if dest > src) to prevent overwriting data that hasn't been read yet. This overhead can make it marginally slower than memcpy in cases where memcpy's optimizations can be fully utilized.
• Guaranteed Correctness: When in doubt about overlap, memmove is the safer choice as it always produces the correct result.

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

int main() {
    char buffer[] = "abcdefgh";
    printf("Original buffer: %s\n", buffer);

    // Safe use of memmove with overlapping regions
    // Copies 'abcde' from buffer[0] to buffer[1]
    memmove(buffer + 1, buffer, 5); 
    printf("Buffer after memmove (dest > src): %s\n", buffer); // Expected: "aabcdegh"

    char another_buffer[] = "1234567890";
    printf("\nOriginal another_buffer: %s\n", another_buffer);

    // Safe use of memmove with overlapping regions (src > dest)
    // Copies '67890' from another_buffer[5] to another_buffer[0]
    memmove(another_buffer, another_buffer + 5, 5); 
    printf("Another buffer after memmove (src > dest): %s\n", another_buffer); // Expected: "6789067890"

    return 0;
}

Illustrates memmove safely handling overlapping memory regions.

sequenceDiagram
    participant Caller
    participant memmove
    participant Memory

    Caller->>memmove: memmove(dest, src, n)
    memmove->>memmove: Check if dest and src overlap
    alt Overlap Detected (dest < src)
        memmove->>Memory: Copy bytes from src to dest (left-to-right)
    else Overlap Detected (dest > src)
        memmove->>Memory: Copy bytes from src to dest (right-to-left)
    else No Overlap
        memmove->>Memory: Copy bytes from src to dest (any order, optimized)
    end
    memmove-->>Caller: Return dest pointer

Internal logic of memmove handling overlapping regions.

When to Use Which

The choice between memcpy and memmove boils down to one critical factor: whether the source and destination memory regions are guaranteed not to overlap.

• Use memcpy when:

  • You are absolutely certain that the source and destination memory blocks do not overlap. This is common when copying from a fixed buffer to another, or when allocating new memory for the destination.
  • Performance is a primary concern, and you can guarantee non-overlap.

• Use memmove when:

  • There is any possibility of overlap between the source and destination memory blocks. This often occurs when shifting elements within the same array or buffer.
  • You are unsure whether the regions overlap, and you prioritize correctness and safety over a potential, minor performance gain.
  • You are implementing a function that takes arbitrary memory pointers and sizes, and you cannot make assumptions about overlap.