在C语言的日常开发中，数组操作是我们最常面对的任务之一。无论是处理从传感器读取的数据流，还是合并来自不同API的JSON解析结果，我们经常需要将两个独立数组的元素整合到一个单独的数组中。在这篇文章中，我们将深入探讨如何在C语言中高效地合并两个数组。
这不仅仅是简单的数据搬运；在这个过程中，我们将会一起探索内存管理的细节、标准库函数的妙用，以及如何编写既安全又高性能的代码。我们会覆盖从基础的循环实现到利用 memcpy 进行内存复制的多种方法，并讨论它们各自的优缺点。无论你是刚入门C语言的新手，还是希望巩固基础知识的资深开发者，这篇文章都会为你提供实用的见解和完整的代码示例。
什么是数组合并？
简单来说，合并两个数组意味着将两个不同数组的元素按照既定的顺序组合到一个新的、更大的数组中。这个过程通常不涉及去重或排序，除非有特定的业务需求。
基本示例
让我们通过一个具体的例子来直观理解。假设我们有两个数组：
- 输入数组 1 (arr1):
[1, 3, 5] - 输入数组 2 (arr2):
[2, 4, 6]
合并后的结果数组将包含第一个数组的所有元素，紧随其后的是第二个数组的所有元素。
- 输出结果:
[1, 3, 5, 2, 4, 6]
重要提示
请注意：本文重点在于讨论基本的数组合并技术，而不涉及排序逻辑。也就是说，我们假设输入数组 INLINECODE0c0087e8 和 INLINECODEf63b64d1 合并后的结果是 [10, 40, 30, 15, 25, 5]，而不是一个有序数组。如果你正在寻找关于合并两个已排序数组的算法，这通常属于“归并排序”的一部分，那是另一个更高级的话题。
方法一：使用 memcpy() 函数的高效方案
对于追求性能的现代C语言开发来说，使用标准库提供的 INLINECODE1494ca20 函数通常是合并数组的首选方案。INLINECODE3fdcef69 是一种内存复制函数，它能够直接在内存级别操作数据，比逐个元素的循环赋值要快得多，特别是在处理大数组时。
核心思路
- 计算空间：首先，我们需要知道两个输入数组的长度（INLINECODEb0dd55cf 和 INLINECODE43b2b94a），并计算出合并后所需的总空间 (
n1 + n2)。 - 动态分配：使用
malloc在堆上动态分配一块足以容纳所有元素的连续内存。 - 内存拷贝：
* 第一次调用 memcpy 将第一个数组的内容复制到新数组的起始位置。
* 第二次调用 memcpy 将第二个数组的内容复制到新数组中第一个数组末尾之后的位置（指针偏移）。
代码实现
下面是一个完整的、带有详细注释的C语言程序示例。在这个例子中，我们编写了一个 mergeArrays 函数，它返回一个指向新数组首地址的指针。
#include
#include
#include
/**
* 合并两个整型数组的函数
* @param arr1 第一个数组
* @param n1 第一个数组的元素个数
* @param arr2 第二个数组
* @param n2 第二个数组的元素个数
* @return 指向合并后新数组的指针
*/
int* mergeArrays(int arr1[], int n1, int arr2[], int n2) {
// 1. 计算合并后数组的总大小
// 注意：这里我们使用 sizeof(int) 来确保分配正确的字节数
int totalSize = n1 + n2;
// 2. 动态分配内存
// 这里如果分配失败，malloc 会返回 NULL，实际生产环境中应增加判空处理
int *res = (int*)malloc(sizeof(int) * totalSize);
if (res == NULL) {
printf("内存分配失败!
");
return NULL;
}
// 3. 使用 memcpy 复制第一个数组
// memcpy(目标地址, 源地址, 字节数)
memcpy(res, arr1, n1 * sizeof(int));
// 4. 使用 memcpy 复制第二个数组
// 目标地址需要偏移 n1 个元素的位置，即 res + n1
memcpy(res + n1, arr2, n2 * sizeof(int));
return res;
}
int main() {
// 定义两个测试数组
int arr1[] = {1, 3, 5};
int arr2[] = {2, 4, 6};
// 计算数组长度
int n1 = sizeof(arr1) / sizeof(arr1[0]);
int n2 = sizeof(arr2) / sizeof(arr2[0]);
// 调用合并函数
int* res = mergeArrays(arr1, n1, arr2, n2);
// 打印结果
if (res != NULL) {
printf("合并后的数组: ");
for (int i = 0; i < n1 + n2; i++) {
printf("%d ", res[i]);
}
printf("
");
// 别忘了释放动态分配的内存！
free(res);
}
return 0;
}
性能分析
- 时间复杂度: O(n1 + n2)。
memcpy通常经过高度优化，能够利用处理器的字长一次性搬运多个字节，因此实际运行速度非常快。 - 辅助空间: O(n1 + n2)。我们需要一个新数组来存储结果，这属于必须的内存开销。
实用见解：为什么选择 memcpy？
在底层开发或高性能计算中，我们倾向于使用 memcpy，因为它减少了循环控制的开销（比如每次迭代的索引递增和边界检查）。当你处理包含百万个元素的数组时，这种差异会变得非常明显。
方法二：手动使用循环（直观且易于调试）
虽然 INLINECODE039beada 很高效，但在某些情况下，我们可能不想依赖库函数，或者我们需要在复制过程中对数据进行某种转换。这时，使用传统的 INLINECODE74c021d7 循环是最直观的方法。
核心思路
- 分配足够大的新数组。
- 使用第一个循环遍历第一个数组，逐个元素赋值给新数组的前半部分。
- 使用第二个循环遍历第二个数组，逐个元素赋值给新数组的后半部分（索引从
n1开始）。
代码实现
这种方法对于初学者来说更容易理解逻辑流程。
#include
#include
// 合并数组的函数实现（手动循环版）
int* mergeArraysManual(int arr1[], int n1, int arr2[], int n2) {
// 计算总大小并分配内存
int *res = (int *)malloc((n1 + n2) * sizeof(int));
if (res == NULL) return NULL; // 安全检查
// 第一步：复制第一个数组
// 我们从索引 0 开始，一直复制到 n1-1
for (int i = 0; i < n1; i++) {
res[i] = arr1[i];
}
// 第二步：复制第二个数组
// 我们从索引 n1 开始（紧接在第一个数组之后），一直复制到 n1+n2-1
for (int i = 0; i < n2; i++) {
res[n1 + i] = arr2[i]; // 注意这里的索引偏移 n1 + i
}
return res;
}
int main() {
int arr1[] = {10, 40, 30};
int n1 = sizeof(arr1) / sizeof(arr1[0]);
int arr2[] = {15, 25, 5};
int n2 = sizeof(arr2) / sizeof(arr2[0]);
// 调用函数进行合并
int *res = mergeArraysManual(arr1, n1, arr2, n2);
if (res != NULL) {
printf("手动合并结果: ");
for (int i = 0; i < n1 + n2; i++) {
printf("%d ", res[i]);
}
printf("
");
free(res); // 释放内存
}
return 0;
}
性能分析
- 时间复杂度: O(n1 + n2)。这是线性的，因为我们访问了每个元素一次。
- 辅助空间: O(n1 + n2)。同样需要额外的空间来存储结果。
方法三：处理静态数组的特殊情况（合并回原数组）
在前面的例子中，我们都使用了动态内存分配（malloc）。但在某些嵌入式系统或资源受限的环境中，我们可能希望直接将第二个数组的内容追加到第一个声明的数组的末尾（前提是第一个数组有足够的多余空间）。
场景描述
假设 INLINECODEd218e6d4 的大小声明为 10，但只装了 3 个元素。我们有 7 个空余位置可以用来装 INLINECODE51c23bd8 的数据。
代码示例
#include
// 将 source 数组合并到 destination 数组中
// destSize: destination 数组的总容量
// destLen: destination 数组当前已有的元素数量
void mergeInPlace(int destination[], int destLen, int source[], int srcLen, int destSize) {
// 检查是否有足够的空间
if (destLen + srcLen > destSize) {
printf("错误：目标数组空间不足！
");
return;
}
// 从 destination 的最后一个有效元素之后开始复制
// destination + destLen 指向了第一个空位的地址
for (int i = 0; i < srcLen; i++) {
destination[destLen + i] = source[i];
}
}
int main() {
// 定义一个足够大的数组作为容器
int arr1[10] = {1, 2, 3};
int arr2[] = {4, 5, 6};
// 计算实际使用的长度和总容量
int currentLen = 3; // arr1 目前有 3 个元素
int totalCapacity = 10; // arr1 总共能装 10 个
int arr2Len = sizeof(arr2) / sizeof(arr2[0]);
printf("合并前 arr1: ");
for(int i=0; i<currentLen; i++) printf("%d ", arr1[i]);
printf("
");
// 调用原地合并函数
mergeInPlace(arr1, currentLen, arr2, arr2Len, totalCapacity);
printf("合并后 arr1: ");
// 现在总长度是 currentLen + arr2Len
for(int i=0; i < currentLen + arr2Len; i++) printf("%d ", arr1[i]);
printf("
");
return 0;
}
这种方法避免了 INLINECODE9ca35664 和 INLINECODE62fd42c1 的开销，在实时系统中非常有用，但需要程序员非常小心地管理数组的大小，防止缓冲区溢出。
最佳实践与常见陷阱
在我们结束之前，我想分享几个在编写这类代码时容易遇到的“坑”，以及如何避免它们。
1. 内存泄漏
当你使用 INLINECODE9054723b 分配内存时，一定要记住在不需要的时候使用 INLINECODE20322775 释放它。在长周期的程序（如服务器服务）中，忘记释放内存会导致内存泄漏，最终耗尽系统资源。
// 错误示范
int* res = mergeArrays(...);
// 做一些操作...
// 函数返回，内存丢失！
// 正确示范
int* res = mergeArrays(...);
if (res != NULL) {
// 使用 res
// ...
free(res); // 归还内存
}
res = NULL; // 防止悬空指针
2. sizeof 的误用
这是一个经典的错误。在将数组作为参数传递给函数时，数组会退化为指针。此时在函数内部使用 INLINECODE11252f97 得到的是指针的大小（通常是4或8字节），而不是数组的总字节大小。这就是为什么我们在上面的所有例子中都显式地传递了数组长度 (INLINECODEbdd7a98c, n2) 作为参数。
3. 整数溢出
如果 INLINECODEf8c02384 和 INLINECODEf7a4e8b4 非常大（接近 INLINECODE1a1d196b），那么 INLINECODEc1750242 可能会导致整数溢出，产生一个负数或很小的数。这会导致 INLINECODEa8e11b5c 分配失败或分配过小的内存，进而导致缓冲区溢出。在极端情况下，建议使用 INLINECODEf0325615 类型而非 int 来处理数组索引和大小。
4. 初始化的重要性
使用 malloc 分配的内存内容是未初始化的（也就是随机的垃圾数据）。虽然我们在合并时会覆盖所有位置，但在某些部分复制或交错复制的算法中，忘记初始化可能会导致严重的Bug。
总结
在C语言中合并数组是一个看似简单实则蕴含许多基础概念的操作。我们学习了如何使用高效的 memcpy 快速搬运内存，也学习了如何使用基础的循环结构来精确控制数据的流向。
- 如果你追求效率，
memcpy是你的不二之选。 - 如果你追求代码的透明度或在复制过程中需要逻辑判断，
for循环更加灵活。 - 如果你工作在内存受限的环境，考虑使用预先分配的静态数组并进行原地合并。
掌握这些基础的数据操作技巧，是构建更复杂算法和系统的基石。希望这篇文章不仅能帮助你解决手头的合并数组问题，还能让你对C语言的内存管理有更深的理解。继续动手实践这些代码，尝试修改它们，看看当输入变化时会发生什么——这才是掌握编程的真正捷径。