C 语言实例 – 数组拷贝（快速上手）

C 语言实例 – 数组拷贝：从零开始掌握数据复制的核心技巧

在学习 C 语言的过程中，数组是最早接触的数据结构之一。而当我们需要将一个数组的内容完整地复制到另一个数组中时，很多人会误以为直接赋值就能完成任务。但事实并非如此。今天我们就来深入剖析一个非常实用的 C 语言实例——数组拷贝。通过这个实例，你不仅能学会如何正确复制数组，还能理解内存管理、指针操作和数据安全等底层概念。

如果你正在为“为什么数组复制后内容变了”“为什么程序崩溃”而头疼，那这篇文章就是为你准备的。我们将从基础语法讲起，逐步过渡到实际应用场景，最后给出完整可运行的代码示例。

为什么不能直接用赋值操作复制数组？

在 C 语言中，数组名本质上是一个常量指针，指向数组的首地址。很多人会尝试这样写：

int arr1[5] = {1, 2, 3, 4, 5};
int arr2[5];

arr2 = arr1;  // ❌ 错误！编译器会报错

这行代码会触发编译错误：error: assignment to expression with array type。为什么会这样？

因为 arr2 是一个数组名，它不是一个变量，不能被重新赋值。换句话说，数组名是“固定地址”，你不能改变它的指向。这就像你不能把“北京”这个城市的名字改成“上海”一样——名字本身不能被修改，只能通过其他方式复制内容。

所以，我们必须手动逐个元素复制，或者使用标准库函数 memcpy 来完成。

创建数组与初始化

在开始拷贝之前，先让我们正确创建并初始化两个数组。

#include <stdio.h>
#include <string.h>  // 用于 memcpy

int main() {
    // 定义一个原始数组，长度为 5
    int source_array[5] = {10, 20, 30, 40, 50};

    // 定义目标数组，用于接收拷贝内容
    int target_array[5];

    // 此处省略初始化，将由后续拷贝操作填充
    return 0;
}

这里我们创建了两个整型数组：source_array 用于存放原始数据，target_array 作为副本接收者。

💡 小贴士：数组初始化时如果未指定所有元素，未指定的元素会自动初始化为 0（全局变量或静态变量）。局部变量则值是随机的，必须手动初始化，避免使用未定义值。

方法一：使用 for 循环逐个复制

这是最基础、最可控的数组拷贝方式。通过循环遍历源数组的每个元素，逐一赋值给目标数组。

#include <stdio.h>

int main() {
    int source_array[5] = {10, 20, 30, 40, 50};
    int target_array[5];

    // 使用 for 循环逐个拷贝
    for (int i = 0; i < 5; i++) {
        target_array[i] = source_array[i];  // 将 source_array 的第 i 个元素赋给 target_array
    }

    // 输出拷贝结果，验证是否成功
    printf("拷贝后的数组内容：\n");
    for (int i = 0; i < 5; i++) {
        printf("target_array[%d] = %d\n", i, target_array[i]);
    }

    return 0;
}

输出结果：

拷贝后的数组内容：
target_array[0] = 10
target_array[1] = 20
target_array[2] = 30
target_array[3] = 40
target_array[4] = 50

✅ 这个方法的优点是逻辑清晰，易于理解，适合初学者掌握。
❌ 缺点是代码量稍多，且容易出错（比如循环边界写错）。

方法二：使用 memcpy 函数高效复制

memcpy 是 C 标准库提供的内存复制函数，专为高效复制任意类型的数据块设计。它比手动循环更快，尤其是在处理大数组时。

#include <stdio.h>
#include <string.h>  // 必须包含此头文件

int main() {
    int source_array[5] = {10, 20, 30, 40, 50};
    int target_array[5];

    // 使用 memcpy 复制内存块
    // 参数说明：
    // 1. 目标地址 (target_array)
    // 2. 源地址 (source_array)
    // 3. 要复制的字节数 (sizeof(int) * 5)
    memcpy(target_array, source_array, sizeof(int) * 5);

    // 输出结果验证
    printf("使用 memcpy 拷贝后的数组：\n");
    for (int i = 0; i < 5; i++) {
        printf("target_array[%d] = %d\n", i, target_array[i]);
    }

    return 0;
}

输出结果：

使用 memcpy 拷贝后的数组：
target_array[0] = 10
target_array[1] = 20
target_array[2] = 30
target_array[3] = 40
target_array[4] = 50

✅ memcpy 的优势在于性能高，代码简洁。
⚠️ 注意：必须确保目标数组有足够的空间容纳源数据，否则会发生缓冲区溢出，导致程序崩溃或安全漏洞。

深拷贝 vs 浅拷贝：理解内存行为的关键

在更复杂的场景中，我们可能会遇到“深拷贝”与“浅拷贝”的问题。虽然在基础数组中不明显，但理解这一点对后续学习结构体、指针数组等高级内容至关重要。

在我们上面的例子中，无论是 for 循环还是 memcpy，都是深拷贝，因为每个数组都有自己独立的内存空间。

int a[3] = {1, 2, 3};
int b[3];

// 以下操作是深拷贝
for (int i = 0; i < 3; i++) {
    b[i] = a[i];
}

此时，修改 b[0] 不会影响 a[0]，它们互不干扰。

实际应用案例：数组反转并保留原数组

我们来做一个稍复杂的 C 语言实例 —— 在不破坏原数组的前提下，复制并反转数组。

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

int main() {
    int original[6] = {1, 2, 3, 4, 5, 6};
    int reversed[6];  // 用于存放反转后的结果

    // 步骤1：先复制原数组（深拷贝）
    memcpy(reversed, original, sizeof(int) * 6);

    // 步骤2：反转数组内容
    for (int i = 0; i < 3; i++) {
        int temp = reversed[i];
        reversed[i] = reversed[5 - i];  // 交换对称位置的元素
        reversed[5 - i] = temp;
    }

    // 输出原数组和反转后的数组
    printf("原数组：");
    for (int i = 0; i < 6; i++) {
        printf("%d ", original[i]);
    }
    printf("\n");

    printf("反转后数组：");
    for (int i = 0; i < 6; i++) {
        printf("%d ", reversed[i]);
    }
    printf("\n");

    return 0;
}

输出结果：

原数组：1 2 3 4 5 6 
反转后数组：6 5 4 3 2 1

这个例子展示了“数组拷贝 + 操作”在实际开发中的典型流程。你先复制一份数据，再进行处理，确保原始数据不受影响。

常见错误与避坑指南

在做 C 语言实例 – 数组拷贝时，以下错误非常常见：

1. 数组越界访问

   for (int i = 0; i <= 5; i++)  // ❌ 应该是 i < 5
   

   这会导致访问 arr[5]，超出数组范围，引发未定义行为。

2. 忘记包含头文件
   使用 memcpy 必须包含 <string.h>，否则会报“未声明的函数”。

3. 目标数组空间不足

   int target[3];
   memcpy(target, source, sizeof(int) * 5);  // ❌ 溢出！
   

   目标数组只有 3 个元素，却试图复制 5 个，后果严重。

4. 使用数组名进行赋值

   arr2 = arr1;  // ❌ 不允许
   

   数组名是常量，不能被赋值。

总结：掌握数组拷贝，奠定编程基础

通过这一系列 C 语言实例 – 数组拷贝的讲解，我们不仅学会了如何正确复制数组，还理解了背后的内存机制和常见陷阱。无论是初学者还是有一定经验的开发者，都应该掌握这些核心概念。

• 对于初学者，建议从 for 循环开始，理解“逐个复制”的逻辑；
• 对于中级开发者，应优先使用 memcpy 提升性能；
• 无论哪种方式，都要注意数组边界和内存安全。

记住：数组拷贝不是“复制名字”，而是“复制内容”。就像你复制一份文件，不是把文件名粘贴过去，而是把里面的文字重新写一遍。

在后续学习中，这些技巧将为你处理结构体、动态内存、字符串操作等复杂任务打下坚实基础。别小看这一小段代码，它背后藏着整个 C 语言的精髓。

如果你觉得这篇文章有帮助，不妨收藏起来，作为日常编码的参考手册。下一期，我们聊聊“C 语言中的字符串操作与内存管理”，敬请期待。