C String memcpy() Function

What You’ll Learn

The memcpy() function from <string.h> copies exactly n bytes from a source block to a destination block. It is one of the fastest ways to duplicate strings, arrays, and raw binary data—provided the destination is large enough and the regions do not overlap.

Definition and Usage

In C, memcpy() is declared in <string.h>. It performs a byte-for-byte copy from src to dest for n bytes. It does not interpret the data as text—it simply moves bytes.

When copying C-strings, you must copy the null terminator if you want dest to be a valid string. That means copying strlen(src) + 1 bytes, not just strlen(src). The destination array must have at least that much space reserved.

📝 Syntax

The standard library declaration:

void *memcpy(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 to copy from.
• n — number of bytes to copy.

Return Value

Returns dest (the destination pointer you passed in).

Header

#include <string.h>

Examples Gallery

Compile with gcc memcpy.c -std=c11 -o memcpy. Each example shows safe buffer sizing, null termination, and when to prefer memmove().

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

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

    size_t bytes = strlen(source) + 1;
    memcpy(destination, source, bytes);

    printf("Source:      %s\n", source);
    printf("Destination: %s\n", destination);
    printf("Bytes copied: %zu\n", bytes);

    return 0;
}

Source:      Hello, C!
Destination: Hello, C!
Bytes copied: 10

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

int main(void) {
    const char *source = "Hello, C Programming!";
    char destination[8];

    memcpy(destination, source, 7);
    destination[7] = '\0';

    printf("Prefix copy: %s\n", destination);

    return 0;
}

Prefix copy: Hello, 

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

int main(void) {
    unsigned char src[] = { 0xDE, 0xAD, 0xBE, 0xEF };
    unsigned char dst[4];

    memcpy(dst, src, sizeof src);

    printf("Copied bytes: %02X %02X %02X %02X\n",
           dst[0], dst[1], dst[2], dst[3]);

    return 0;
}

Copied bytes: DE AD BE EF

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

int main(void) {
    char buffer[32];
    const char *tag = "C";

    char *end = memcpy(buffer, "Hello, ", 7);
    end = memcpy(end, tag, strlen(tag) + 1);

    printf("%s\n", buffer);

    return 0;
}

Hello, C

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

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

    /* Safe: shift "bcdef" left by one position */
    memmove(text, text + 1, 5);
    text[5] = '\0';

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

    /* memcpy(text, text + 1, 5);  // UNDEFINED if overlapping */

    return 0;
}

After memmove: bcdef

🚀 Common Use Cases

• String duplication — copy text into a new buffer when you control the destination size.
• Array copying — duplicate struct arrays or byte buffers in one call.
• Protocol packets — assemble fixed-layout messages from template bytes.
• Graphics / audio — copy pixel or sample blocks between buffers.
• Serialization — move raw memory into an output buffer before writing to disk or network.

📝 Notes

• Buffer size — dest must have room for at least n bytes. Writing beyond the buffer is undefined behavior.
• No overlap — if src and dest overlap, use memmove() instead.
• Null terminator — copying strlen(s) bytes alone does not make a C-string; include + 1 or append '\0' manually.
• Not for allocation — memcpy does not allocate memory; you must provide both buffers.
• Order of evaluation — do not rely on overlapping read/write side effects with memcpy.

⚡ Optimization

Standard library memcpy() implementations are heavily optimized—often using word-aligned bulk copies. For large transfers, calling memcpy directly beats a naive byte loop. Copy only the bytes you need; avoid redundant copies in hot paths.

💡 Best Practices