How to Use memcpy in C: A Complete Guide with Examples

By 佐川 直弘 | Naohiro Sagawa (運営者)

※記事内に広告を含みます。Amazonアソシエイトとして適格販売により収入を得ています。　

1. What is memcpy? The Basics

When working with memory in C, copying data is a fundamental operation. One of the most common functions used for this is memcpy. It allows you to copy data from one memory area to another, byte by byte. You can think of it like “moving items from Box A to Box B as-is.” That said, there are a few important caveats when using memcpy. If you don’t specify the correct size or memory regions, it can lead to data corruption or even crash your program.

2. How memcpy Works

memcpy has the following function signature:

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

dest is the destination (where the data will be copied to), src is the source (where the data will be copied from), and n is the number of bytes to copy. For example, the following code copies an array:

char src[10] = "ABCDEF";
char dest[10];
memcpy(dest, src, 6); // Copy "ABCDEF"

This code copies the first 6 bytes from src to dest. It’s important to make sure that the size of the data being copied fits within both the source and destination memory regions. If the sizes don’t match properly, the program may behave unexpectedly.

3. Common Pitfalls of memcpy

The biggest pitfall of memcpy is the issue of overlapping memory regions. memcpy does not work correctly if the source and destination memory areas overlap. For example, the following code can cause problems:

char data[] = "HelloWorld";
memcpy(data + 2, data, 5);

In this case, the source and destination memory areas overlap, which can lead to corrupted results. To handle overlapping regions safely, you should use memmove instead. memmove is designed to handle such situations correctly and safely.

4. Best Practices for Using memcpy

Here are some best practices to safely use memcpy:

1. Verify the size: Always make sure the number of bytes you’re copying is correct. If the destination buffer is too small, it can cause a buffer overflow, which poses a serious security risk.
2. Check for NULL pointers: If either src or dest is NULL, your program could crash. Always check that both pointers are valid before using them.
3. Avoid overlapping memory regions: Don’t use memcpy when the source and destination overlap. In those cases, use memmove instead to prevent unexpected behavior.

5. Performance and Advantages of memcpy

The biggest advantage of memcpy is its speed. On many systems, memcpy is highly optimized at the hardware level, making it ideal for copying large amounts of data between non-overlapping memory regions. For example, it’s commonly used when loading large buffers or file data into memory.

However, don’t overuse memcpy just for the sake of performance. In cases where memory regions might overlap, or when security is a concern, you should consider using memmove or other safer alternatives.

6. Alternatives to memcpy: memmove and Other Options

While memcpy is extremely useful, it’s important to know about its alternatives. memmove is a safer option when dealing with overlapping memory regions, as it handles such cases properly. For example, you can use memmove like this to move data safely:

char data[] = "HelloWorld";
memmove(data + 2, data, 5);

In this example, memmove copies the data correctly without corruption. Additionally, depending on your needs, functions like strcpy or strncpy may be more appropriate, especially when working with strings. Choosing the right function for the right context is key.

7. Summary

In this article, we covered the C language function memcpy, including how it works, common pitfalls, best practices, and alternative functions. memcpy is a powerful tool, but it must be used carefully to avoid issues. Always pay close attention to memory safety and ensure you’re copying the correct size.

One final reminder: if the source and destination memory regions overlap, don’t hesitate—use memmove instead. Following these guidelines will help keep your programs safe and reliable.