内存函数(C语言)

07-16 840阅读

内存函数

以下函数的头文件：string.h

针对内存块进行处理的函数

memcpy

函数原型：

void* memcpy(void* destination, const void* source, size_t num);
					目标空间地址                源空间地址

num，被拷贝的字节个数
返回目标空间的起始地址
从source函数向后拷贝num字节个数据到目标空间
目标空间地址和源空间地址有重叠部分，有重叠内存的拷贝，结果是未定义的

C语言标准规定：memcpy可以不负责有重叠内存的拷贝

而vs编译器的库函数也可以实现重叠内存的拷贝。

#include 
#include 
int main()
{
	int arr1[20] = { 1, 2, 3, 4, 5, 6 };
	int arr2[20] = { 0 };
	memcpy(arr2, arr1, sizeof(int) * 5);
	for (int i = 0; i  
 
通过函数原型也发现，这个memcpy函数是一个函数参数，函数返回类型都是void无符号类型，这是说明该函数是一个，泛型函数，它可以接收任意类型的参数，使同一个函数能用于多种类型的数据。 
该用例说明了，将数组arr1从第一个元素开始的20个字节拷贝到arr2中。 
模拟memcpy函数 
void* my_memcpy(void* dest, const void* src, size_t num)
{
    void* ret = dest;
    assert(dest && src);
    while(num--)
    {
        *(char*)dest = *(char*)src;
        dest = (char*)dest + 1;
        src = (char*)src + 1;
    }
	return ret;
}
 
该函数是泛型函数，在返回类型和参数上要保持一致，后面的size_t num参数用来接收拷贝的字节个数。 
能够进行任意数据类型的拷贝，这里只能将源空间一个一个字节拷贝到目标空间里，而void类型不是4个字节，所以将，dest和src强制类型转换为char类型，这样每循环一次就拷贝一个字节的内容，然后让指针dest和src向后走一个字节。 
(char*)dest++;与dest = *(char*)dest + 1;的区别： 
c/c++里的强制类型转换，是临时的，（char*）dest++；试图将一个 void *类型的dest强制类型转换，然后++，语法是有问题的，对 （char *）dest使用++，实际上是 (char* dest) = dest + 1;，将无符号类型的指针赋给 char *类型的指针编译器会报错的
 
最后将目标空间的起始地址返回即可。 
使用assert断言是因为，目标空间和源空间都不能为空，否则就是对空指针解引用，加一条assert是代码具有更好的健壮性。 
memmove 
函数原型： 
void* memmove(void* destination, const void* source, size_t num);

负责重叠内存的拷贝
用法与memcpy相同。
memmove可以是memcpy的替代，它支持更多的使用场景，重叠内存的拷贝。
模拟memmove函数

俩个函数的功能及其相似，它们在实现上的不同，模拟memcpy函数是，对字节进行拷贝时，是将source里的字节从前向后一个一个拷贝的，如图：

source里一共有12个字节，模拟的memcpy函数将从数字2开始的第一个字节，一个一个拷贝到目标空间里。

若两快空间重叠时会发生哪些情况：
- dest指针大于source指针，目标空间与源空间重叠，但目标空间起始地址小于源空间，此时针对情况一，如上图橘色与蓝色重叠部分
- dest指针小于source指针，目标空间与源空间重叠，但目标空间起始地址大于源空间，此时针对情况二，如上图绿色与蓝色重叠部分
  情况一：
  - 当使用从前向后一个一个字节的拷贝时， 0 被拷贝为 2，1 被拷贝为 3，2 被拷贝为 4，结果与预期相符和，所以当目标空间与源空间重叠，但目标空间起始地址小于源空间时，采用从前向后一个字节一个字节的拷贝。
    
    情况二：
    - 对应情况二使用从前向后一次拷贝字节时，将源空间内容拷贝到密目标空间，此时 4 被拷贝为 2 ， 5 被拷贝为 3 ， 6被拷贝为2。
    - 与预期结果并不相符和，预期拷贝后的结果时 0 1 2 3 2 3 4。
    - 实际结果为，0 1 2 3 2 3 2。
      
      可以发现，使用从前向后一起拷贝字节时，源空间的内容覆盖掉，它还没有拷贝就已经被覆盖了，并将其放置在目标空间的最后一个位置。解决这种办法也很好理解，既然从前向后拷贝不行，那我们从后向前拷贝不久可以了。这样就避免了，还没有将源空间的数据拷贝到目标空间就被覆盖的情况。
      
      将source指针和destination指针向后偏移num个字节， (char*)dest + num (char*)src + num，这样它两就指向最后一个字节，从后向前拷贝，每拷贝完一个字节后 num–。
```
void* my_memmove(void* dest, const void* src, size_t num)
{
    void* ret = dest;
    assert(dest && src);
    if(dest > src)//后向前
    {
        while(num--)
        {
             *((char*)dest + num) = *((char*)src + num);
		}
	}
    else
    {
        while(num--)
    	{
        	*(char*)dest = *(char*)src;
        	dest = *(char*)dest + 1;
            src = *(char*)src + 1;
        }
	}
    return ret;
}
```
      当dest > src时，从后向前，第一步将dest和src偏移到最后一个位置， (char*)dest + num (char*)src + num，然后进行赋值，
      
      *((char *)dest ) = *((char *)src );，其代码内讲多块内容合并在一起操作，通过控制num大小，来控制了dest和src偏移的位置，而循环结束的条件的num为0，这样就有了一条很精简的代码。
      
      memset
      
      函数原型：
```
void* memset(void* ptr, int value, size_t num);
             被填充空间    改变的内容 设置的字节个数       
```
      memset，是用来设置内存的，将内存以字节为单位，
      - 将每个字节设置为 value的内容
        很朴素的用法，没有过多的变化，但结果往往会让人出乎意料~。
        
        int main() { int arr1[20] = { 1, 2, 3, 4, 5, 6 }; int arr2[20] = { 0 }; memset(arr2, 9, 5); memset(arr1, 8, 5); for (int i = 0; i
        这不是一个使用的案例，通过运行代码能够发现数组arr1和arr2的结果相当的大，这是因为memset是在字节上设置内容，这里的第一条memset语句，将数组arr2里的五个字节内容，都放置了一个数字9，而内存里的 09 09 09 09实际上是16进制数，0x09090909，所以在打印的结果上会很大。
        
        数字arr1的结果，同数组arr2一样，即使在传递的数组这块内容已经放的有值，memset还会将其覆盖。
        
        这里以字符串为例，字符串的大小是一个字节，这里我试图将字符数组arr1里的前三个字节内容置为x。
        
        int main() { char arr1[10] = "abcdef"; memset(arr1, 'x', 3); return 0; }
        
        观察结果，memset函数指哪打哪~，也没有在最后一个x后多余的放置 '\0'。
        
        memcmp
        
        函数原型：
        
        int memcmp(const void* ptr1, const void* ptr2, size_t num);
        
        比较字节大小：
        
        ptr1 > ptr2 返回大于0
        ptr1
        等于返回 0
        num是指比较字节个数
        memcmp函数与字符串函数里的strncmp功能很类似，前者是通过比较字节大小，后者是比较字符大小。
        
        int main() { int arr1[] = { 1, 2, 5 }; int arr2[] = { 1, 2, 6 }; printf("%d \n", memcmp(arr1, arr2, 8)); return 0; }
        
        arr1前12个字节：
        
        01 00 00 00 02 00 00 00 05 00 00 00
        
        arr2前12个字节
        
        01 00 00 00 02 00 00 00 06 00 00 00
        
        试图比较前8个字节的大小时，返回的结果是0，每个字节上的内容都是相等的，而 memcmp(arr1, arr2, 9)；，比较前9个字节大小时，将返回小于0的数字， 06 > 05 。
        
        cmp(arr1, arr2, 8));
        return 0;
        }
        arr1前12个字节：
        
        01 00 00 00 02 00 00 00 05 00 00 00
        
        arr2前12个字节
        
        01 00 00 00 02 00 00 00 06 00 00 00
        
        试图比较前8个字节的大小时，返回的结果是0，每个字节上的内容都是相等的，而 memcmp(arr1, arr2, 9)；，比较前9个字节大小时，将返回小于0的数字， 06 > 05 。