模拟实现C语言--memcpy函数和memmove函数
文章目录
- 模拟实现C语言--memcpy函数和memmove函数
- 一、memcpy函数和memmove函数
-
- [1.1 memcpy函数是什么](#1.1 memcpy函数是什么)
- [1.1 memmove函数是什么](#1.1 memmove函数是什么)
- 二、使用示例
-
- [2.1 从起始位置复制](#2.1 从起始位置复制)
- [2.2 从任意位置复制](#2.2 从任意位置复制)
- 三、模拟实现
-
- [3.1 模拟实现1--memcpy函数](#3.1 模拟实现1--memcpy函数)
- [3.2 针对缺点改进的模拟实现2--memmove函数](#3.2 针对缺点改进的模拟实现2--memmove函数)
-
- [3.2.1 刨析原因](#3.2.1 刨析原因)
- [3.2.2 改正方法](#3.2.2 改正方法)
- [3.2.3 代码--模拟实现memmove函数](#3.2.3 代码--模拟实现memmove函数)
- [3.2.4 memcpy函数和memmove函数平台问题](#3.2.4 memcpy函数和memmove函数平台问题)
一、memcpy函数和memmove函数
1.1 memcpy函数是什么
c
void * memcpy ( void * destination, const void * source, size_t num );- strcpy函数是字符串拷贝函数，只能拷贝字符串，而其他类型无法使用strcpy函数拷贝
- 而memcpy函数属于内存拷贝函数，可以拷贝其他类型。
1.1 memmove函数是什么
c
void * memmove ( void* destination, const void * source, size_t num );- 和memcpy的差别就是memmove函数处理的源内存块和目标内存块是可以重叠的。
- 如果源空间和目标空间出现重叠，就得使用memmove函数处理。
二、使用示例
- 函数memcpy从source的位置开始向后复制num个字节的数据到destination的内存位置。
- 这个函数在遇到 '\0' 的时候并不会停下来
- 如果source和destination有任何的重叠，复制的结果都是未定义的。
2.1 从起始位置复制
c
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include <string.h>
int main()
{
int i = 0;
int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
int arr2[10] = { 0 };
memcpy(arr2, arr1, 20);
for (i = 0; i < 10; i++)
{
printf("%d ", arr2[i]);
}
return 0;
}
2.2 从任意位置复制
c
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include <string.h>
int main()
{
int i = 0;
int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
int arr2[10] = { 0 };
memcpy(arr2, arr1+2, 20);
for (i = 0; i < 10; i++)
{
printf("%d ", arr2[i]);
}
return 0;
}
三、模拟实现
3.1 模拟实现1--memcpy函数
c
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include <string.h>
#include <assert.h>
void* my_memcpy(void* destination, const void* source, size_t num)
{
void* ret = destination;
assert(destination);
assert(source);
/*
* copy from lower addresses to higher addresses
*/
while (num--)
{
*(char*)destination = *(char*)source;
destination = (char*)destination + 1;
source = (char*)source + 1;
}
return(ret);
}
int main()
{
int i = 0;
int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
int arr2[10] = { 0 };
my_memcpy(arr2, arr1+2, 20);
for (i = 0; i < 10; i++)
{
printf("%d ", arr2[i]);
}
return 0;
}
3.2 针对缺点改进的模拟实现2--memmove函数
模拟实现1的代码有一个缺陷，就是不能进行自我拷贝
c
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include <string.h>
#include <assert.h>
void* my_memcpy(void* destination, const void* source, size_t num)
{
void* ret = destination;
assert(destination);
assert(source);
/*
* copy from lower addresses to higher addresses
*/
while (num--)
{
*(char*)destination = *(char*)source;
destination = (char*)destination + 1;
source = (char*)source + 1;
}
return(ret);
}
int main()
{
int i = 0;
int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
int arr2[10] = { 0 };
my_memcpy(arr1+2, arr1, 20);
for (i = 0; i < 10; i++)
{
printf("%d ", arr1[i]);
}
return 0;
}
3.2.1 刨析原因
3.2.2 改正方法
- 当dst指针指向的地址在src指针指向位置的右边时，这种情况的赋值应该从后向前赋值，就是12345，先让5赋值在7的位置，依次循环
- 当dst指针指向的地址在src指针指向位置的右边时，这种情况的赋值应该从前向后赋值，34567，先将3赋值给1的位置，依次循环
3.2.3 代码--模拟实现memmove函数
c
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include <string.h>
#include <assert.h>
void* my_memmove(void* destination, const void* source, size_t num)
{
void* ret = destination;
assert(destination);
assert(source);
if (destination < source)
{
//从前向后赋值
while (num--)
{
*(char*)destination = *(char*)source;
destination = (char*)destination + 1;
source = (char*)source + 1;
}
}
//从后向前赋值
else
{
while (num--)
{
*((char*)destination+num)= *((char*)source+num);
}
}
return ret;
}
int main()
{
int i = 0;
int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
int arr2[10] = { 0 };
my_memmove(arr1+2, arr1, 20);
for (i = 0; i < 10; i++)
{
printf("%d ", arr1[i]);
}
return 0;
}
3.2.4 memcpy函数和memmove函数平台问题
目前在vs环境下，这两个函数基本没有区别，memcpy也可以解决内存重复的问题。别的平台可能还是会有这个问题