【C语言】精妙运用内存函数：深入底层逻辑的探索

文章目录

• 一、内存函数的使用
• • 1.1 Memcpy(内存拷贝函数)
  • • 1.1.1 特殊情况:当dest和sour出现重叠拷贝（访问同一块空间）
    • 1.1.3 VS下解决了重叠拷贝的问题
    • 1.2 Memmove(内存拷贝函数)
    • 1.3 Memset(初始化函数)
    • 1.4 Memcmp(内存对比函数)
    • 二、模拟实现内存函数
    • • 2.1 模拟实现Memcpy
      • 2.2 模拟实现Memmove

        🔥引言

        上篇文章介绍了字符串相关函数，但是缺点在于只针对于字符类型。

        本篇文章涉及的函数不单单只能用于字符类型的数据，通过内存进行修改适用于任意类型数据，逐字节修改。

        内存函数大部分在string.h头文件中进行声明。

        

        

        🌈个人主页：是店小二呀

        🌈C语言笔记专栏：C语言笔记

        🌈C++笔记专栏： C++笔记

        🌈喜欢的诗句:无人扶我青云志 我自踏雪至山巅

        

        ---

        文章目录

        • 一、内存函数的使用
        • • 1.1 Memcpy(内存拷贝函数)
          • • 1.1.1 特殊情况:当dest和sour出现重叠拷贝（访问同一块空间）
            • 1.1.3 VS下解决了重叠拷贝的问题
            • 1.2 Memmove(内存拷贝函数)
            • 1.3 Memset(初始化函数)
            • 1.4 Memcmp(内存对比函数)
            • 二、模拟实现内存函数
            • • 2.1 模拟实现Memcpy
              • 2.2 模拟实现Memmove

                ---

                一、内存函数的使用

                1.1 Memcpy(内存拷贝函数)

                

                #include 
                #include 
                int main()
                {
                    //定义两个数组
                	int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
                	int p[20] = { 0 };
                    
                	memcpy(arr, p, 20);
                	for (int i = 0; i  
                 
                【说明】：
                 
                

                • 从source位置开始向后内存拷贝num个字节的数据到destination指向的内存空间（逐一拷贝）
                  • 函数遇到'\0'的时候不会停下，跟这点strncpy是类似的

                    1.1.1 特殊情况:当dest和sour出现重叠拷贝（访问同一块空间）

                    int main()
                    {
                        int nums[] = { 1,2,3,4,5,6,7,8,9,10 };
                        //预期结果:1 2 1 2 3 6 7 8 9 10
                        //20个字节 - 5个整型类型的大小
                        memcpy(nums + 2, nums, 12);
                        for (int i = 0; i  
                     
                    【说明】:
                     
                    

                    • 这里就是数组第三个位置数据被修改，导致拷贝时出现拷贝错误。
                    • 如果将代码拷贝到VS下运行，会发现结果是正确的。VS解决memcpy重叠拷贝问题
                    • 但是memcpy导致的问题，不能单单依靠编译器，如果是其他环境，就不知道哪里出现问题了

                      1.1.3 VS下解决了重叠拷贝的问题

                      

                      【解决措施】：为了解决这种情况，标准库提供一个用于处理重叠内存的函数memmove

                      1.2 Memmove(内存拷贝函数)

                      

                      int main()
                      {
                        int nums[] = { 1,2,3,4,5,6,7,8,9,10 };
                          //预期结果:1 2 1 2 3 6 7 8 9 10
                          //20个字节 - 5个整型类型的大小
                          memcpy(nums + 2, nums, 12);
                          for (int i = 0; i  
                      【说明】：跟memcpy功能相同，区别在于memmove可以处理源内存和目标内存中重叠的部分的场景
                       
                      【使用推荐】:如果不想考虑会出现重叠拷贝的情况，推荐直接使用memmove可以的
                       
                      1.3 Memset(初始化函数)
                       
                       
                      int main()
                      {
                          char str[] = "ooooooooooooooo";
                          memset(str, 'I', 10);
                          printf("%s", str);
                          return 0;
                      }
                       
                       
                      【说明】：从str指向位置，根据要求字节个数去设置内存中数据
                       
                      1.4 Memcmp(内存对比函数)
                       
                       
                      int main()
                      {
                      	char str1[] = "bbbbbb";
                      	char str2[] = "abcdef";
                      	int ret=memcmp(str1, str2,2);
                      	printf("%d", ret);
                      	return 0;
                      }
                       
                      【说明】：
                       
                      

                      • 比较str1和str2前num个值（字节为单位）如果在num前发现了不同，则返回比较结果

                      • str1 > str2 ，返回大于零数据

                      • str1 = str2， 返回等于零数据

                      • str

                        ---

                        二、模拟实现内存函数

                        这里我们主要讲模拟实现内存函数memcpy和memmove内存函数，不同类型的数据都存放在内存当中，如果我们想打破类型的限制对不同类型的数据进行修改，就需要通过内存入手，内存单元对于着字节，那么就是从每一个字节入手，由于memcpy相对memmove是不能处理重叠的数据，所以难点和重点在于模拟实现memmove

                        2.1 模拟实现Memcpy

                        #include 
                        void* my_memcpy(void* str1, void** str2,int sz)
                        {
                        	assert(str1 && str2);
                        	void* ret = str1;
                        	while (sz--)
                        	{
                        		*(char*)str1 = *(char*)str2;
                        		str1 = (char*)str1 + 1;
                        		str2 = (char*)str2 + 1;
                        	}
                        	return ret;
                        }
                        int main()
                        {
                        	int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
                        	int arr2[10] = {0};
                        	my_memcpy(arr1,arr2,20);
                        	int i = 0;
                        	for (int i = 0; i  
                        【说明】：
                         
                        

                        • 对内存中的数据进行修改，就是对每个字节修改，那么我们需要强制类型转化char*类型

                        • 当寻找下一个字节的时候，需要注意步数，指针类型决定了指针向前先后的步数

                          2.2 模拟实现Memmove

                          面对出现拷贝重叠情况，我们需要关注dest和str的位置关系，从而判断从前向后拷贝，还是从后向前

                          

                          

                          【判断标准】：通过dest和str位置来进行判断

                          • 当dest void* ret = str; int n = count; if (dest while (count--) { *(char*)str = *(char*)dest; str = (char*)str + 1; dest = (char*)dest + 1; } } else//从后面开始拷贝条件复杂，就else { dest=(char *)dest+count-1; str=(char *)str+count-1; while (count--) { *(char*)str = *(char*)dest; str = (char*)str - 1; dest = (char*)dest - 1; } } return ret; } int main() { int arr[] = { 1,2,3,4,5,6,7,8,9,10 }; my_memmove(arr+2, arr, 20); for (int i = 0; i