四种拷贝函数详解与工业级拷贝实现
目录
一、引言
内存拷贝我们在编程的过程中会经常遇到，调用C库的函数也无非是memcpy()、memmove()、strcpy()、strncpy()这几个函数，但是很少考虑过它们的实现原型和具体的差异；当遇到自己实现一个内存拷贝的原型时，却发现细节考虑的不是很到位，如果问你的人是面试官，结果可想而知；
内存拷贝的实现问题非常具有代表性，原理也是比较简单，但是能反映以下几个重要问题：思维逻辑性、考虑问题的全面性、细节的把握能力。细思极恐呐！本文就和大家一起讨论讨论四种拷贝函数和工业级拷贝实现。
二、四种拷贝函数详解
1、memcpy()函数
- 概览
| 原型 |
|
| 功能 | memcpy()会复制 src 所指的内存内容的前 num 个字节到 dest所指的内存地址上； memcpy()并不关心被复制的数据类型，只是逐字节地进行复制，这给函数的使用带来了很大的灵活性，可以面向任何数据类型进行复制； |
| 注意 | dest 指针要分配足够的空间，也即大于等于 num字节的空间。如果没有分配空间，会出现断错误； 与 strcpy() 不同的是，memcpy() 会完整的复制 num个字节，不会因为遇到“\0”而结束； |
| 返回值 | 返回指向 dest 的指针。注意返回的指针类型是void，使用时一般要进行强制类型转换。 |
- 举例
#include <string,h>
#include <stdio.h>
#include <stdlib.h>
#define N (15)
int main()
{
char *p1 = "qing zhu yi!";
char *p2 = (char *)malloc(sizeof(char) * N);
char *p3 = (char *)memcpy(p2, p1, N);
printf("p2 = %s\np3 = %s\n", p2, p3);
free(p2);
p2 = NULL;
p3 = NULL;
system("pause");
return 0;
}
| 运行结果 | p2 = qing zhu yi! p3 = qing zhu yi! |
| 代码说明 | 1) 代码首先定义p1，p2，p3三个指针，但略有不同，p1指向一个字符串字面值，给p2分配了10个字节的内存空间； 2) 指针p3通过函数memcpy直接指向了指针p2所指向的内存，也就是说指针p2、p3指向了同一块内存。然后打印 p2，p3指向的内存值，结果是相同的； 3) 最后按照好的习惯释放p2，并把p3也置为NULL是为了防止再次访问p3指向的内存，导致野指针的发生； |
2、memmove()函数
- 概览
| 原型 |
|
| 功能 | memcpy()会复制 src 所指的内存内容的前 num 个字节到 dest所指的内存地址上； |
| 注意 | memmove() 更为灵活，当src 和 dest所指的内存区域重叠时，memmove() 仍然可以正确的处理，不过执行效率上会比使用 memcpy()略慢些。 |
| 返回值 | 返回指向 dest 的指针。注意返回的指针类型是void，使用时一般要进行强制类型转换。 |
- 举例
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main ()
{
char str[] = "memmove can be very useful......";
memmove (str+20,str+15,11);
puts (str);
system("pause");
return 0;
} | 运行结果 | memmove can be very very useful. |
| 代码说明 | 处理内存重叠时的情况：先将内容复制到类似缓冲区的地方，再用缓冲区中的内容覆盖 dest指向的内存 |
3、strcpy()函数
- 概览
| 原型 |
|
| 功能 | strcpy() 把src所指的由NULL结束的字符串复制到dest 所指的数组中，返回指向dest 字符串的起始地址。 |
| 注意 | 如果参数 dest 所指的内存空间不够大，可能会造成缓冲溢出(bufferOverflow)的错误情况，在编写程序时需要特别留意，或者用strncpy()来取代 |
| 返回值 | 指向dest 字符串的起始地址 |
- 举例
#include <stdio.h>
#include <string.h>
int main ()
{
char str1[]="Sample string";
char str2[40];
char str3[40];
strcpy (str2,str1);
strcpy (str3,"copy successful");
printf ("str1: %s\nstr2: %s\nstr3: %s\n",str1,str2,str3);
return 0;
}
| 运行结果 | str1: Sample string str2: Sample string str3: copy successful |
| 代码说明 | 无 |
4、strncpy()函数
- 概览
| 原型 |
|
| 功能 | strncpy()会将字符串src前n个字符拷贝到字符串dest |
| 注意 | 不像strcpy()，strncpy()不会向dest追加结束标记'\0'，这就引发了很多不合常理的问题，将在下面的示例中说明 |
| 返回值 | 指向dest 字符串的起始地址 |
- 举例
#include <stdio.h>
#include <string.h>
int main(void)
{
char dest1[20];
char src1[] = "abc";
int n1 = 3;
char dest2[20] = "********************";
char src2[] = "abcxyz";
int n2 = strlen(src2) + 1;
char dest3[100] = "http://see.xidian.edu.cn/cpp/shell/";
char src3[6] = "abcxyz"; // 没有'\0'
int n3 = 20;
char dest4[100] = "http://see.xidian.edu.cn/cpp/u/yuanma/";
char src4[] = "abc\0defghigk";
int n4 = strlen(src3);
strncpy(dest1, src1, n1); // n1小于strlen(str1)+1，不会追加'\0'
strncpy(dest2, src2, n2); // n2等于strlen(str2)+1，恰好可以把src2末尾的'\0'拷贝到dest2
strncpy(dest3, src3, n3); // n3大于strlen(str3)+1，循环拷贝str3
strncpy(dest4, src4, n4); // src4中间出现'\0'
printf("dest1=%s\n", dest1);
printf("dest2=%s, dest2[15]=%c\n", dest2, dest2[10]);
printf("dest3=%s\n", dest3);
printf("dest4=%s, dest4[6]=%d, dest4[20]=%d, dest4[90]=%d\n", dest4, dest4[6], dest4[20], dest4[90]);
return 0;
}
三、工业级拷贝函数实现
1、易出错和忽略出现的几个问题
- 输入输出普适性问题
需要拷贝的数据有不同的类型，为了普适性函数将这样定义原型：
void* memcpy(void* dst, const void* src, int count );
原因有二：
(1)、指针的类型为什么是void* 。首先我们需要明白一个概念上的区别即void 和 void* 。void表示空的意思，不可以用void修饰任何变量，void最常见的两种用法：函数返回值为空；函数参数为空，表示不接受调用参数。这两个用法相信大家很清楚，在此不再赘述。而void* 表示的是任意类型的指针，可通过任意类型的指针进行赋值，在此需要注意的是：不可以对void* 进行算术运算，不可以对void* 进行解引用，原因很明确，void*表示的是任意类型的指针，不同类型的指针进行算术运算结果显然不同。
使用void* 指针，可以接受任意类型的指针的赋值，可以使用任何指针类型的参数来调用函数。在内部可以用char类型强制转换就可以，具体参考【3】。
(2)、src为什么用const修饰。引用effective C++中03条款：尽可能使用const。
src为要复制的原地址，仅仅是希望读取他的内容，并不希望在操作的过程中改变它，因此const可以确保src的常量性。
- 目标地址和源地址所指内存区域重叠问题
(1) 地址不重叠 (dst src || dst
(char*)src+count)
如果满足上面条件，说明源目地址肯定不重叠或者即使重叠也不会影响数据的复制，这时候不需要担心内容被覆盖的问题。直接进行复制即可.
char* psrc=(char*)src;
char* pdst=(char*)dst;
if(pdst && psrc)
{
while(count--)
{
*pdst++ = *psrc++;
}
}注：只有当dst > (char*)src+count*sizeof(*src)时，才是真正的源目地址不重叠；
当dst (char*)src时，可以看出地址可能会重叠，但是不影响拷贝数据的准确性。
(2) 地址重叠 src dst
src+count
这种情况下，和在有序数组中插入新元素一样，在移动元素的时候，为了防止覆盖，从后面元素依次开始移动。这里一样的道理，为了防止地址之间的重叠造成覆盖，我们从高地址开始复制内容。具体实现如下：
if(dst>=src && (char*)dst<(char*)src+count)
{
char* psrc=(char*)src+count-1;
char* pdst=(char*)dst+count-1;
while(count--)
{
*pdst--=*psrc--;
}
}- 实参地址是否有效问题
试想，如果有用户这样来调用你的memcpy函数，memcpy(null,p,5)或者memcpy（p,null,5）肯定编译器不会报错，但是执行结果却是不可预料的。所以，我们还要对源目地址作是否为空的判断来确定是否可以正常使用。
使用assert可解决问题，同时避免了执行判断语句 if( null==src || null==dst )带来的执行开销。
assert(src);
assert(dst);2、流程图
3、代码实现
void * memMove(void *dest, const void * src, int count)
{
assert(dest);
assert(src);
void * result = dest;
char * p_src = src;
char * p_dest = dest;
if(dest <= src || (char *)dest >= (char *)src + count) // 地址不重叠，从前往后拷贝
{
while(count--)
{
*(char *)dest++ = *(char *)src++;
}
}
else // 地址重叠，从后往前拷贝
{
p_src = (char *)src + count - 1;
p_dest = (char *)dest + count -1;
while(count--)
{
*p_dest-- = *p_src--;
}
}
return result;
}四、总结
（1）当源内存的首地址等于目标内存的首地址时，不进行任何拷贝
（2）当源内存的首地址大于目标内存的首地址时，实行正向拷贝
（3）当源内存的首地址小于目标内存的首地址时，实行反向拷贝
图解：
当src内存区域和dst内存区域完全不重叠
当src内存区域和dest内存区域重叠时且dst所在区域在src所在区域前
当src内存区域和dst内存区域重叠时且src所在区域在dst所在区域前
五、参考文献
[1] C语言的四种拷贝函数
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
