C String memmove() Function

What You’ll Learn

The memmove() function from <string.h> copies n bytes from source to destination—just like memcpy()—but it is safe when the two regions overlap. That makes it the right choice for shifting text inside one buffer or any in-place memory rearrangement.

Definition and Usage

In C, memmove() is declared in <string.h>. It transfers n bytes from src to dest and returns dest. When the ranges overlap, the implementation copies in the correct direction so source bytes are not overwritten before they are read.

Use memmove() whenever source and destination might be the same array or share memory—for example, removing the first character from a string or inserting bytes in the middle of a buffer. When regions are guaranteed disjoint, memcpy() is also valid and may be marginally faster.

📝 Syntax

The standard library declaration:

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

Parameters

• dest — pointer to the destination buffer (must hold at least n bytes).
• src — pointer to the source data.
• n — number of bytes to copy.

Return Value

Returns dest (the destination pointer).

Header

#include <string.h>

Examples Gallery

Compile with gcc memmove.c -std=c11 -o memmove. Examples progress from simple copies to overlap-safe in-place shifts.

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

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

    memmove(destination, source, strlen(source) + 1);

    printf("Source:      %s\n", source);
    printf("Destination: %s\n", destination);

    return 0;
}

Source:      Hello, C!
Destination: Hello, C!

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

int main(void) {
    char text[] = "abcdef";

    memmove(text, text + 1, strlen(text));
    /* copies "bcdef\0" starting at text[0] */

    printf("After shift left: %s\n", text);

    return 0;
}

After shift left: bcdef

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

int main(void) {
    char text[] = "world";
    size_t len = strlen(text);

    memmove(text + 1, text, len + 1);
    text[0] = 'H';

    printf("Result: %s\n", text);

    return 0;
}

Result: Hworld

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

int main(void) {
    char word[] = "Hello";
    size_t removeAt = 1;  /* remove 'e' at index 1 */

    memmove(word + removeAt, word + removeAt + 1,
            strlen(word) - removeAt);

    printf("After removal: %s\n", word);

    return 0;
}

After removal: Hllo

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

int main(void) {
    char src[] = "Copy me";
    char dst[16];

    /* Safe: separate arrays, no overlap */
    memcpy(dst, src, strlen(src) + 1);
    printf("memcpy result:  %s\n", dst);

    char buffer[] = "overlap";
    /* Unsafe if uncommented — src and dest overlap: */
    /* memcpy(buffer, buffer + 2, 6); */

    memmove(buffer, buffer + 2, 6);
    printf("memmove result: %s\n", buffer);

    return 0;
}

memcpy result:  Copy me
memmove result: erlap

🚀 Common Use Cases

• In-place string edits — delete or insert characters without a second buffer.
• Buffer compaction — shift live data to the start of an array after removing headers.
• Safe generic copy — use when overlap cannot be ruled out in library code.
• Ring buffers — rearrange bytes when linearizing circular queue contents.
• Defensive coding — prefer memmove when pointer arithmetic makes overlap possible.

📝 Notes

• memmove is always safe for overlap; memcpy is not.
• Destination must still have room for n bytes—overflow rules apply like memcpy.
• For C-strings, copy strlen(s) + 1 unless you intentionally handle termination separately.
• When shifting right, ensure the buffer is large enough for the expanded content.
• For disjoint copies where performance is critical, memcpy may be preferred after proving no overlap.

⚡ Optimization

memmove() may add a small overhead compared to memcpy() because it must handle overlap. Use memcpy in hot paths only when you have proven the regions are disjoint. Otherwise, the safety of memmove outweighs the tiny cost difference in most applications.

💡 Best Practices