用C语言编写自己的memcpy()函数.doc

### 用C语言编写自己的memcpy()函数

在C语言标准库中，`memcpy()`是一个用于内存块复制的高效函数，其原型定义在``中。它的核心功能是将源内存区域（`src`）的连续字节复制到目标内存区域（`dest`），并返回目标指针。尽管标准库的实现通常经过高度优化，但理解其底层原理并手动实现一个简化版，对深入掌握内存操作、指针运算和边界处理具有重要意义。

#### 一、标准memcpy()的原型与行为

标准库的`memcpy()`函数原型如下：

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

参数说明：

`dest`：目标内存地址（需确保可写）。
`src`：源内存地址（需确保可读）。
`n`：要复制的字节数。

关键特性：

不检查内存重叠：若`src`和`dest`重叠，行为未定义（需用`memmove()`处理重叠情况）。
按字节复制：无论数据类型如何，均以字节为单位操作。
返回`dest`：支持链式调用（如`ptr = memcpy(dest, src, n)`）。

#### 二、手动实现memcpy()的步骤

实现自定义`memcpy()`需解决以下问题：

类型转换：将`void*`转换为可操作的`char*`（字节指针）。
循环复制：逐字节或按机器字长（如4字节）复制以提高效率。
边界处理：确保不越界访问。
返回值：返回`dest`指针。

##### 1. 基础逐字节复制实现

最简单的实现是逐个字节复制：

#include  // 用于size_t

void *my_memcpy(void *dest, const void *src, size_t n) {
    if (dest == NULL || src == NULL || n == 0) {
        return dest; // 处理空指针或零长度
    }

    char *d = (char *)dest;
    const char *s = (const char *)src;

    for (size_t i = 0; i

**缺点**：循环次数多，效率低，尤其对大内存块。

##### 2. 按机器字长优化

现代CPU通常按字长（如4字节）访问内存更快。可通过按`uint32_t`或`uintptr_t`复制优化：

#include 
#include 

void *my_memcpy_optimized(void *dest, const void *src, size_t n) {
    if (dest == NULL || src == NULL || n == 0) {
        return dest;
    }

    char *d = (char *)dest;
    const char *s = (const char *)src;
    size_t aligned_size = n / sizeof(uint32_t);
    size_t remainder = n % sizeof(uint32_t);

    // 按4字节复制（假设uint32_t为4字节）
    for (size_t i = 0; i

**问题**：

假设`uint32_t`为4字节，可能不跨平台。
未处理内存对齐（若`dest`或`src`未对齐到4字节边界，某些架构会崩溃）。

##### 3. 对齐优化与跨平台改进

更健壮的实现需动态检测字长并处理对齐：

#include 
#include 
#include  // 用于size_t

// 检测机器字长（简化版，实际需更复杂逻辑）
#define WORD_SIZE sizeof(uintptr_t)

void *my_memcpy_robust(void *dest, const void *src, size_t n) {
    if (dest == NULL || src == NULL || n == 0) {
        return dest;
    }

    char *d = (char *)dest;
    const char *s = (const char *)src;
    size_t aligned_bytes = n & ~(WORD_SIZE - 1); // 对齐到字长边界
    size_t remainder = n % WORD_SIZE;

    // 按字长复制（需确保d和s对齐）
    for (size_t i = 0; i

**改进点**：

使用`uintptr_t`（无符号整数，大小与指针相同）。
通过位运算计算对齐边界。
仍需确保`dest`和`src`对齐，否则需先逐字节复制至对齐位置。

##### 4. 完整实现（处理未对齐内存）

以下实现自动处理未对齐内存，并尽可能按字长复制：

#include 
#include 

#define WORD_SIZE sizeof(uintptr_t)

void *my_memcpy_final(void *dest, const void *src, size_t n) {
    if (dest == NULL || src == NULL || n == 0) {
        return dest;
    }

    char *d = (char *)dest;
    const char *s = (const char *)src;
    size_t offset = (uintptr_t)d % WORD_SIZE; // 计算未对齐偏移

    // 处理起始未对齐部分（逐字节复制至对齐位置）
    if (offset != 0) {
        size_t align_offset = WORD_SIZE - offset;
        size_t to_copy = (n

**说明**：

先计算`dest`的未对齐偏移量。
逐字节复制至对齐位置。
按字长复制剩余部分。
最后处理剩余不足一个字长的字节。

#### 三、测试与验证

编写测试用例验证自定义`memcpy()`的正确性：

#include 
#include 

void test_memcpy() {
    char src[] = "Hello, World!";
    char dest[20];

    // 测试基础功能
    my_memcpy_final(dest, src, strlen(src) + 1);
    printf("Test 1: %s\n", dest); // 应输出"Hello, World!"

    // 测试零长度
    my_memcpy_final(dest, src, 0);
    printf("Test 2 (zero length): %s\n", dest); // 应不变

    // 测试结构体复制
    struct Point { int x; int y; };
    struct Point p1 = {10, 20};
    struct Point p2;
    my_memcpy_final(&p2, &p1, sizeof(struct Point));
    printf("Test 3: p2.x=%d, p2.y=%d\n", p2.x, p2.y); // 应输出10, 20

    // 测试内存重叠（需用memmove处理，此处应失败）
    char overlap[10] = "123456789";
    my_memcpy_final(overlap, overlap + 2, 5);
    printf("Test 4 (overlap, undefined): %s\n", overlap); // 行为未定义
}

int main() {
    test_memcpy();
    return 0;
}

**注意事项**：