精华内容
下载资源
问答
  • c语言内存复制函数
    2022-02-21 16:12:29
    void * memcpy ( void * destination , const void * source , size_t num );
            该函数是内存操作的拷贝函数, 函数 memcpy source 的位置开始向后复制 num 个字节的数据到 destination的内存位置,在遇到 '\0' 的时候并不会停下来。同时该函数的返回类型和参数类型为void*,这也就说明了该函数的业务逻辑不仅仅可以对字符串进行拷贝,还可以对其他数据类型进行拷贝,这就是它与strcpy函数最大的不同。
            谈到这个函数,就会想到它的姊妹memmove函数,两者之间有何差别?
            对于老版本的编译器来说,可能两者之间的差别就是 memmove 函数处理的源内存块和目标内存块是可以重叠的。但是经过实践证明,对于较新版本的编译器来说两者几乎无差别都可以处理内存重叠问题,可以认为mencpy约等于memmove。因此在进行模拟实现的时候只实现一种,这里我选择实现memcpy函数。
            ​​​​​​模拟实现前的问题分析:
            由于函数参数是无类型指针,因此传入的参数要进行类型强转,这里选择无符号字符指针强转,以1字节为单位进行拷贝。在设计时要考虑空间重叠问题,如果传入的参数内存空间不重叠,则正常的从左向右拷贝即可正常完成;但是如果空间重叠,比如dst指针指向的是src指针指向字节的后一个字节,则拷贝出来的字符串是源字符串的一串首字符。比如,“hello”我们把该字符串拷贝到该字符串字符e以后的位置,由于两个字符串的字符e以后的地址发生重叠,我们的预期效果是“hhello”,但是结果为“hhhhhh”,根本原因是因为h字符拷贝到e字符时,h字符的指针覆盖掉e字符的指针,然后把e字符拷贝到l字符时,实际上e字符的指针经过第一次拷贝变成了h字符的指针,也就是l
    字符的指针仍然是h字符的指针,依次进行下去就是“hhhhhh”。
            问题解决:
            我们采用从右向左拷贝,这样拷贝过的字符就不会造成内存重叠引起的问题了。
            
    //模拟memcpy
    void* my_memcpy(void* dst, const void* src, int count)
    {
    	assert(dst != NULL);
    	assert(src != NULL);
    	if (count <= 0) {
    		return NULL;
    	}
    	unsigned char* _dst = (unsigned char*)dst;
    	unsigned char* _src = (unsigned char*)src;
    	//right->left
    	if (_dst > _src && _dst < _src + count) {
    		_src = _src + count - 1;
    		_dst = _dst + count - 1;
    		while (count) {
    			*_dst = *_src;
    			_dst--;
    			_src--;
    			count--;
    		}
    	}
    	//left->right
    	else {
    		while (count) {
    			*_dst = *_src;
    			_dst++;
    			_src++;
    			count--;
    		}
    	}
    	return dst;
    }
    

    更多相关内容
  • c语言内存拷贝 memcpy()函数

    千次阅读 2021-12-13 23:59:13
    需包含头文件:C 标准库 - <string.h> 文章目录描述声明参数返回值实例1实例2...下面是 memcpy() 函数的声明。 void *memcpy(void *str1, const void *str2, size_t n) 参数 str1 -- 指向用于存储复制内容的目标

    需包含头文件:C 标准库 - <string.h>

    描述

    C 库函数 void *memcpy(void *str1, const void *str2, size_t n) 从存储区 str2 复制 n 个字节到存储区 str1。

    声明

    下面是 memcpy() 函数的声明。

    void *memcpy(void *str1, const void *str2, size_t n)
    

    参数

    str1 -- 指向用于存储复制内容的目标数组,类型强制转换为 void* 指针。
    str2 -- 指向要复制的数据源,类型强制转换为 void* 指针。
    n -- 要被复制的字节数。
    

    返回值

    该函数返回一个指向目标存储区 str1 的指针。

    实例1

    下面的实例演示了 memcpy() 函数的用法。

    // 将字符串复制到数组 dest 中
    #include <stdio.h>
    #include <string.h>
     
    int main ()
    {
       const char src[50] = "http://www.runoob.com";
       char dest[50];
     
       memcpy(dest, src, strlen(src)+1);
       printf("dest = %s\n", dest);
       
       return(0);
    }
    

    运行结果:

    dest = http://www.runoob.com
    

    实例2

    #include <stdio.h>
    #include<string.h>
    
    int main()
    
    {
    	const char* s = "http://www.runoob.com";
    	char d[20];
    	memcpy(d, s + 11, 6);// 从第 11 个字符(r)开始复制,连续复制 6 个字符(runoob)
    	// 或者 memcpy(d, s+11*sizeof(char), 6*sizeof(char));
    	d[6] = '\0';
    	printf("%s", d);
    	return 0;
    }
    

    运行结果:

    runoob
    

    实例3:覆盖原有部分数据

    #include<stdio.h>
    #include<string.h>
    
    int main(void)
    {
    	char src[] = "***";
    	char dest[] = "abcdefg";
    	printf("使用 memcpy 前: %s\n", dest);
    	memcpy(dest, src, strlen(src));
    	printf("使用 memcpy 后: %s\n", dest);
    	return 0;
    }
    

    运行结果:

    使用 memcpy 前: abcdefg
    使用 memcpy 后: ***defg
    

    参考文章:C 库函数 - memcpy()

    展开全文
  • C语言内存函数总结

    2022-01-21 20:07:45
    目录 一、内存拷贝函数memcpy(): 二、内存拷贝函数memmove(): 三、内存比较函数memcpy(): 四、内存设置函数memset(): ...2.函数memcpy从src的位置开始向后复制count个字节的数据到dest的内存位置。 3...

    目录

    一、内存拷贝函数memcpy():

     二、内存拷贝函数memmove():

    三、内存比较函数memcpy():

     四、内存设置函数memset():


    一、内存拷贝函数memcpy():

    void *memcpy( void *dest, const void *src, size_t count );

    1.引用头文件<memory.h> or <string.h>

    2.函数memcpysrc的位置开始向后复制count个字节的数据到dest的内存位置。

    3.这个函数在遇到 '\0' 的时候并不会停下来。

    4.如果srcdest有任何的重叠,复制的结果都是未定义的。

    #include <stdio.h>
    #include <stdio.h>
    #include <string.h>
    struct 
    {
    	char name[40];
    	int age;
    } person, person_copy;
    int main()
    {
    	char myname[] = "Pierre de Fermat";
    
    	memcpy(person.name, myname, strlen(myname) + 1);//复制字符串
    	person.age = 46;	
    	memcpy(&person_copy, &person, sizeof(person));//复制结构体
    	printf("person_copy: %s, %d\n", person_copy.name, person_copy.age);
    
    	return 0;
    }

    编译并运行该代码,输出如下:

    person_copy:Pierre de Fermat, 46

    5.自定义实现该函数:

    #include <stdio.h>
    #include <assert.h>
    void* MyMemcpy(void* dest, const void* src, size_t count)//你不知道要拷贝什么,所以用void*来接收
    {
    	void* ret = dest;//为了最后可以返回起始空间的地址
    	assert(dest && src);
    	while (count--)//一个一个字节拷贝
    	{
    		*(char*)dest = *(char*)src;
    		dest = (char*)dest + 1;//dest++ error因为dest是void*类型
    		src = (char*)src + 1;
    	}
    	return ret;
    }
    int main()
    {
    	int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
        int i;
    
    	MyMemcpy(arr + 2, arr, 16);
    	for (i = 0; i < 10; i++)
    	{
    		printf("%d ", arr[i]);
    	}
    
    	return 0;
    }

    编译运行该代码,输出如下:

    1 2 1 2 1 2 7 8 9 10

    //可以看到结果并不是我们想象的1 2 1 2 3 4 7 8 9 10,原因不是我们的自定义函数出错了,而是因为如果srcdest有任何的重叠,复制的结果都是未定义的

     二、内存拷贝函数memmove():

    void *memmove( void *dest, const void *src, size_t count );

    1.引用头文件<string.h>

    2.memcpy()的差别就是memmove函数处理的源内存块和目标内存块是可以重叠的。

    3.自定义实现该函数:

    void* MyMemmove(void* dest, const void* src, size_t count)//src指向的内容不可以修改,但是src可以被修改
    {
    	void* ret = dest;
    	assert(src && dest);
    	if (dest < src)
    	{
    		//前->后
    		while (count--)//一个一个字节拷贝    
    		{
    			*(char*)dest = *(char*)src;
    			dest = (char*)dest + 1;
    			src = (char*)src + 1;
    		}
    		
    	}
    	else
    	{
    		//后->前
    		while (count--)
    		{
    			*((char*)dest + count) = *((char*)src + count);//count=15;
    		}
    	}
    	return ret;
    }
    int main()
    {
    	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
    
    	MyMemmove(arr + 2, arr, 16);
    	int i;
    	for (i = 0; i < 10; i++)
    	{
    		printf("%d ", arr[i]);
    	}
    	return 0;
    }
    

    编译运行该代码,输出如下:

    1 2 1 2 3 4 7 8 9 10

    //这回正是我们想要的结果

    三、内存比较函数memcpy():

    void *memcpy( void *buf1, const void *buf2, size_t count );

    1、引用头文件<string.h>或<memory.h>

    2、比较从buf1 和buf2 指针开始的count 字节
    3、返回值如下:

     四、内存设置函数memset():

    void *memset( void *dest, int c, size_t count );

    1、引用头文件<string.h>或<memory.h>

    2、将dest中当前位置后面的count个字节用 c替换并返回dest。

    展开全文
  • C语言内存操作函数

    千次阅读 2022-03-26 00:29:42
    关于C语言内存操作函数
    1.
    memcpy();   //内存单元复制  (不可以自己给自己追加)
    void * memcpy ( void * dest, const void * src, size_t num ); //目标起始地址,  要复制内存单元起始地址 , 复制的数量(单位是字节)
    • 函数memcpy从src的位置开始向后复制num个字节的数据到dest的内存位置。

    • 这个函数在遇到'\0'的时候并不会停下来。

    • 如果src和dest有任何的重叠,复制的结果都是未定义的。

    头文件: memory.h 或 string.h
    strcpy()只能复制字符串, memcpy()什么类型的数据都可以进行复制

     

    #include <string.h>
    int main()
    {
             int arr1[10] = { 1,2,3,4,5,6,7,8,9,10 };
             int arr2[5] = { 0 };
            memcpy(arr2, arr1, 20);
             //把arr1的20个内存单元复制给arr2 , 单位是字节
    }

     


     

     2.

    memmove();   //内存单元复制 (可以自己给自己追加)
    void * memmove ( void * dest, const void * src, size_t num ); //目标起始地址,  要复制内存单元起始地址 , 复制的数量(单位是字节)
    • 和memcpy的差别就是memmove函数处理的源内存块和目标内存块是可以重叠的。
    • 如果源空间和目标空间出现重叠,就得使用memmove函数处理。
    #include <string.h>
    int main()
    {
             int arr1[10] = { 1,2,3,4,5,6,7,8,9,10 };
            memmove(arr1 + 2, arr1, 20);
             //把arr1 的20个内存单元复制给 arr1+2 的位置 , 单位是字节
             return 0;
    }

     

    //arr1 给 arr1自己进行了复制,并且重叠

    //如果是上面 模拟实现memcpy 的方法,数据会被替换, 无法实现重叠,结果会是: 12121218910 //err


     3.

    memset();  //修改内存中的单元   , 单位是字节
    void* memset( void* dest, int c, size_t count );  //目标起始地址,  修改内存单元的起始地址 , 修改的内存单元数量(单位是字节)
    #include <string.h>
    int main()
    {
             int arr[] = { 0x11111111,0x22222222,3,4,5 };
            memset(arr, 0, 20);
             return 0;
    }
    内存单元从:

     变为:

     //没有变红的部分,也变0了,只不过本来是0,所以编译器没有变红提示


    4.

    memcmp(); //内存单元比较, 单位是字节
    int memcmp ( const void * ptr1, const void * ptr2, size_t num );   //目标起始地址,  比较的内存单元的起始地址 , 比较的数量
    • 比较从ptr1和ptr2指针开始的num个字节
    • 返回值和strcmp一样:
      • >返回>0的值   
      • ==返回0 
      • <返回<0的值
    #include <stdio.h>
    #include <string.h>
    int main()
    {
             int arr1[] = { 1,2,3,4,5 };
             int arr2[] = { 1,2,3,4,0x11223305 }; //小端存储,所以第17个字节是05
             int ret = memcmp(arr1, arr2, 17); //所以对比17个字节都相等
            printf( "%d\n", ret);
             return 0;
    }

     

     

    但是如果比较的元素是18个的话, 就是不相等的, 这是对arr2的第18的内存单元33 进行和arr1的第18的内存单元00 进行比较, 

    结果返回小于0的值, 不同编译器下会不同, 当前返回的是-1

     //如果是字符在内存中进行比较,比较的是它们相对应的ASCII码值,

    //所以会出现 'A' < 'a' 这种情况,因为'A' 的ASCII码值是:65   而 'a' 的ASCII码值是:97

    展开全文
  • C语言中memcpy 函数的用法详解 memcpy(内存拷贝函数) c和c++使用的内存拷贝函数,memcpy函数的功能是从源src所指的内存地址的起始位置开始拷贝n个字节到目标dest所指的内存地址的起始位置中。 void* memcpy(void* ...
  • 前言:内存区域划分与分配:1、栈区(stack)——程序运行时由编译器自动分配,存放函数的参数值,局部变量的值等,程序结束时由编译器自动释放。2、堆区(heap)——在内存开辟另一块存储区域。一般由程序员分配释放, ...
  • C语言 内存函数

    2022-03-15 17:03:32
    C语言 内存函数一、内存复制函数1.1 memcpy函数1.2 memmove函数二、内存比较函数 memcmp三、内存查找字符函数 memchr四、内存设置函数 memset 前言:C语言提供了许多与内存相关函数,可以在头文件<string.h>中...
  • C语言内存操作函数

    千次阅读 2018-07-23 11:22:05
    功能:函数memcpy从src的位置开始向后复制num个字节的数据到dest的内存位置 说明: 这个函数在遇到’\0’不会停下来 如果src与dest任何的重叠,复制结果都是未定义的 memmove void* memmove(void* dest,c....
  • 很多新学C语言的童鞋在用到动态内存分配的时候,对选择哪种分配函数及其有何区别搞不清楚,那么下文就认真的讲讲它们的种种。 (1)C语言内存分配方式 从静态存储区域分配 这些在程序编译的时候就已经分配好,且...
  • C语言——内存函数

    千次阅读 2022-03-24 11:11:48
    常见的内存函数 memcpy memmove memcmp memset memcpy 这个函数到底是干什么的呢? 用大白话来说:用来复制的(从他的名字中就能看出来,copy),根据他的声明可能可以理解的更好。 函数声明 void *memcpy(void *...
  • C语言内存管理函数

    千次阅读 2016-06-04 11:26:39
    C语言内存管理函数 memset函数void *memset(void *ptr, int val, size_t num);函数作用:用来将制定指定的前n个字节设置为特定的值。参数说明:ptr为要操作的内存的函数。value为要设置的值。既可以向value传递int...
  • 内存拷贝函数的一般用法 有两种拷贝函数,strcpy()和memcpy(),strcpy()只能对字符串进行拷贝复制,十分不通用,但是memcpy()可以对任意两个相同类型的数据进行拷贝复制,极大地方便了编程过程中的一些特殊需要。 ...
  • 1.写一个函数,完成内存之间的拷贝。[考虑问题是否全面]void* memcpy( void *dest, const void *src, size_t count ){char* pdest = static_cast( dest );const char* psrc = static_cast( src );if( pdest>psrc ...
  • 利用C语言中的函数实现文件的Copy

    千次阅读 2021-05-25 07:04:22
    描述用C语言实现字符串拷贝函数有几种方式首先是使用库函数比如下面代码123void ourStrCopy(char S1[] , char S2[]){strcpy(S1, S2); //该函数还有另一个版本可以按长度截取}还有一个函数是memcpy,这个是内存...
  • 从source位置向后复制num个字节数据到destination的内存位置中。 2.memmove void * memmove ( void * destination, const void * source, size_t num ); 与memcpy函数功能和用法相同;都可以处理source内存块和...
  • memcpy函数(memory+copy)顾名思义是内存拷贝函数,具体的功能是将src地址处的count个字节拷贝到dest地址处,头文件<memory.h> or <string.h>,其语法为: void *memcpy( void *dest, const void *...
  • C语言 常用内存函数

    2019-07-29 19:45:24
    C语言 常用内存函数 1.memset memset在头文件memory.h中 头文件memory.h为内存操作函数头文件 memset 第一个参数是内存的首地址,第二个参数是要设置的字符,第三个参数是正数,从首地址开始...2.memcpy 内存复制 me...
  • Linux 中C语言getcwd()函数的用法 先来看该函数的声明: #include char *getcwd(char *buf,size_t size); 介绍: 参数说明:getcwd()会将当前工作目录的绝对路径复制到参数buffer所指的内存空间中,参数size为buf...
  • C语言常用功能函数集合 说明:作者将个人接触到的C语言功能函数记录下来,组成一个集合,便于查阅和加深印象。 1. 内存相关 malloc()函数 :申请一片连续的堆内存,字节为单位。分配所需的内存空间,并返回一个...
  • 头文件:#include 功能:把从src地址开始且含有NULL结束符的字符串复制到以dest开始的地址空间说明:src和dest所指内存区域不可以重叠且dest必须有足够的空间来容纳src的字符串。返回指向dest的指针。函数实现: ...
  • C语言 字符串函数

    千次阅读 2022-03-13 18:58:49
    C语言提供了许多与字符串相关函数,可以在头文件<string.h>中查看函数声明,本章将会自行编写相关字符串函数 一、字符串长度函数 strlen 功能:字符串以 ‘\0’ 作为结束标志,strlen函数返回的是在字符串中 ...
  • 主要介绍了C语言中字符串的内存地址操作的相关函数,包括bcopy()函数和bzero()函数以及bcmp()函数,需要的朋友可以参考下
  • strcpy,即string copy(字符串复制)的缩写。 原型声明:char *strcpy(char *...说明:src和dest所指内存区域不可以重叠且dest必须有足够的空间来容纳src的字符串。 返回指向dest的指针(返回类型char*)。 不使用C/C
  • c语言回调函数的使用及实际作用详解

    万次阅读 多人点赞 2021-07-16 23:49:20
    回调函数这个知识点其实并不是很难,难是难在网上很多讲解回调函数的都说的太学术化了化了,一点也不亲民。 很多人即使知道怎么写回调函数也根本就搞不懂它们在实际产品中也有什么用,什么时候用。 所以这节课呢...
  • C语言函数内存中的调用机制

    千次阅读 2020-05-31 11:55:59
    1.首先说单文件编程(就是所有的代码都在主函数main.c中编写)函数是如何调用的,再引入多文件编程函数如何调用的 //main.c中的代码如下 #include <stdio.h> int add(flaot x,float y) { return (x+y); } int ...
  • C语言中的内存函数有如下这些memcpymemmovememcmpmemset下面看看memcpy函数memcpy我们想想,之前有那个字符串拷贝的函数,即strcpy函数。都有拷贝的函数了,为什么还要这个内存拷贝函数呢?不能直接用strcpy吗?这是...
  • C语言库函数memcpy函数模拟实现
  • 功能:函数从source中复制num个字节到destination中,并返回destination指针。 如果destination 和source 重叠,则函数行为不确定 因为参数的类型都是void*,所以传任何类型的数据都可以,传多少由第三个参数字节数...
  • 头文件:#include <string.h>...定义函数:char *strcpy(char *dest, const char *src); 函数说明:strcpy()会将参数src 字符串拷贝至参数dest 所指的地址。 返回值:返回参数dest 的字符串起始地址。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 85,056
精华内容 34,022
关键字:

c语言内存复制函数