精华内容
下载资源
问答
  • 内存重叠

    2018-05-12 20:35:53
    内存重叠:拷贝的目的地址在源地址范围内,所谓内存重叠就是拷贝的目的地址和源地址有重叠。1,3图不会出现内存重叠的问题,而2,4会出现内存重叠的问题。...

    内存重叠:拷贝的目的地址在源地址范围内,所谓内存重叠就是拷贝的目的地址和源地址有重叠。

    1,3图不会出现内存重叠的问题,而2,4会出现内存重叠的问题。


    展开全文
  • v1.0可编辑可修改 v1.0可编辑可修改 PAGE PAGE # 内存重叠拷贝的目的地址在源地址范围内所谓内存重叠就是拷贝的目的地址和源地址 有重叠 在函数strcpy和函数memcpy都没有对内存重叠做处理的 使用这两个函数的时候...
  • 内存重叠问题

    2018-04-19 11:23:58
    均不允许内存重叠的。 二、 出现内存重叠问题的条件: (1)src 在 des 的左边; (2)src + size_t count > des至字符串结束剩余长度。 解决方法:从后至前进行拷贝(src 与 des 同时 count-1) 三、memmove

    一、
    在内存拷贝时候, strcpy/strncpy/strcat/strncat/memcpy(not ensure!!)
    均不允许内存重叠的。
    这里写图片描述

    二、
    出现内存重叠问题的条件:
    (1)src 在 des 的左边;
    (2)src + size_t count > des至字符串结束剩余长度。
    解决方法:从后至前进行拷贝(src 与 des 同时 count-1)

    三、
    对不同情况下,内存拷贝的处理方法:

    (1)从后至前:依次- -
    ①满足上述出现内存重叠的两个条件;
    ②src 与 des 不在同一块内存空间。
    这里写图片描述

    (2)从前至后:依次++
    ①正常情况(即不会发生内存重叠情况);assert(des<=src || src+count>des);
    ②src 与 des 不在同一块内存空间。

    if(des > src && src + count < des)
    {
        tmp_des += count - 1;
        tmp_src += count - 1;
        while(count--)
        {
           *--tmp_des = *--src;
        }
    }//情况(1)
    else
    {
        while(count--)
        {
           *tmp_des++ = *tmp_src;
        }
    }//情况(2)

    四、
    memcpy替代的解决方法是memmove(ensure!!). 原型是:

    void *memmove( void* dest, const void* src, size_t count ); 
    展开全文
  • 内存重叠:拷贝的目的地址在源地址范围内。所谓内存重叠就是拷贝的目的地址和源地址有重叠。在函数strcpy和函数memcpy都没有对内存重叠做处理的,使用这两个函数的时候只有程序员自己保证源地址和目标地址不重叠。...

    内存重叠:拷贝的目的地址在源地址范围内。所谓内存重叠就是拷贝的目的地址和源地址有重叠。

    在函数strcpy和函数memcpy都没有对内存重叠做处理的,使用这两个函数的时候只有程序员自己保证源地址和目标地址不重叠。

    使用memmove函数可解决内存重叠问题。memmove函数对内存重叠做了处理。


    重叠从两方面考虑:

    (1).dest数据覆盖了source; 如:dest(8byte) 地址:1000

    source(8byte) 地址:1002

    (2).dest所指的区域本来就是source的一部分; 如:dest(8byte) 地址:1000

    source(8byte) 地址:0998

    例如:针对第一种交叉情况情况,dst<src且dst+count>src,memcpy和memmove的结果是一样的。请看下面的例子讲解:

    string s = "hello world";

    memmove(&s[0],&s[5],10);



    1.下面来看strcpy(): 字符串拷贝. 

    char *strcpy(char *strDest, const char *strSrc)
    {
    assert((strDest!=NULL) && (strSrc !=NULL));
    char *address = strDest; 
    while( (*strDest++ = * strSrc++) != '\0') 
       ; 
    return address ; 
    }

    2.下面来看下memcpy函数:内存拷贝

    void *memcpy(void *dest, const void *source, size_t count)
    {
       assert((NULL != dest) && (NULL != source));
    
       char *tmp_dest = (char *)dest;
       char *tmp_source = (char *)source;
       while(count --)//不对是否存在重叠区域进行判断
           *tmp_dest ++ = *tmp_source ++;
       return dest;
    }

    3.下面来看下memmove函数:

    void* _memmove(void* dest, const void* src, size_t count)
    {
    	assert(src != nullptr && dest != nullptr);
    	char* tmp_dest = (char*)dest;
    	const char* tmp_src = (const char*)src;
    
    	if (tmp_src < tmp_dest)//当src地址小于dest地址时,从后向前拷贝,保证dest数据正确
    	{
    		tmp_src += count - 1;
    		tmp_dest += count - 1;
    		while (count--)
    			*tmp_dest-- = *tmp_src--;
    	}
    		
    	else if (tmp_src > tmp_dest)//当src地址大于dest地址时,从前向后拷贝,保证dest数据正确
    	{
    		while (count--)
    			*tmp_dest++ = *tmp_src++;
    	}
    	//else(tmp_src==tmp_dest) 此时不进行任何操作
    	return dest;
    }

    以上是我自己的理解,下面是百度的别人的代码,有待研究:

    void *memmove(void *dest, const void *source, size_t count)
    {
    assert((NULL != dest) && (NULL != source));
    char *tmp_source, *tmp_dest;
    tmp_source = (char *)source;
    tmp_dest = (char *)dest;
    if((dest + count<source) || (source + count) <dest))
    {// 如果没有重叠区域
    while(count--)
    *tmp_dest++ = *tmp_source++;
    }
    else
    { //如果有重叠(反向拷贝)
    tmp_source += count - 1;
    tmp_dest += count - 1;
    while(count--)
    *--tmp_dest = *--tmp;
    }
    return dest;
    }


    ...


    展开全文
  • memcpy内存重叠问题

    千次阅读 2016-08-06 11:54:49
    memcpy内存重叠之前一直没有注意到内存复制函数的内存重叠问题。今天偶遇遂琢磨了一下,记之。函数简介:c和c++使用的内存拷贝函数,memcpy函数的功能是从源src所指的内存地址的起始位置开始拷贝n个字节到目标dest所...

    memcpy内存重叠

    之前一直没有注意到内存复制函数的内存重叠问题。今天偶遇遂琢磨了一下,记之。

    函数简介:c和c++使用的内存拷贝函数,memcpy函数的功能是从源src所指的内存地址的起始位置开始拷贝n个字节到目标dest所指的内存地址的起始位置中。一般避免内存重叠。

    没有内存重叠的情况:

    void *mymemcpy(void *dst,const void *src,size_t num)  
    {  
           if(NULL == dst || NULL == src){  
           return NULL;  
           }  
           //assert((dst !=NULL) && (src!=NULL));
    
           if(dst>=src+num||src>dst+num){  
            char * psrc = (char *)src;
            char * pdst = (char *)dst;  
            while(num-->0)*pdst++ = *psrc++;  
           }  
           return dst;  
    }  

    出现内存重叠的情况

    void * mymemcpy(void *dst, const void *src, size_t count)  
    {  
        if (dst== NULL || src == NULL)  
              return NULL;  
        char *pdest = (char *)(dst);  
        const char *psrc  = (char *)(psrc);  
        int n = count;  
        //pdest地址高于psrc地址,且有重叠
        if (pdest > psrc && pdest < psrc+count)  
        {  
            for (size_t i=n-1; i != -1; --i)  
            {  
                    pdest[i] = psrc[i];//从高到低赋值  
            }  
        }  
        //pdest地址低于psrc地址,且有重叠
        else if(pdest < psrc && pdest > psrc-count)
        {  
            for (size_t i= 0; i < n; i++)  
            {  
                    pdest[i] = psrc[i];//从低到高赋值  
            }  
        }  
        return dst;  
    }  
    

    附录:关于memmove,memcpy

    1.memmove
    函数原型:void *memmove(void *dest, const void *source, size_t count)
    返回值说明:返回指向dest的void *指针
    参数说明:dest,source分别为目标串和源串的首地址。count为要移动的字符的个数
    函数说明:memmove用于从source拷贝count个字符到dest,如果目标区域和源区域有重叠的话,memmove能够保证源串在被覆盖之前将重叠区域的字节拷贝到目标区域中(此时源字符串尾部字符改变)。
    2.memcpy
    函数原型:void *memcpy(void *dest, const void *source, size_t count);
    返回值说明:返回指向dest的void *指针
    函数说明:memcpy功能和memmove相同,但是memcpy中dest和source中的区域不能重叠,否则会出现未知结果。
    3.两者区别
    函数memcpy() 从source 指向的区域向dest指向的区域复制count个字符,如果两数组重叠,不定义该函数的行为。
    而memmove(),如果两函数重叠,赋值仍正确进行。
    memcpy函数假设要复制的内存区域不存在重叠,如果你能确保你进行复制操作的的内存区域没有任何重叠,可以直接用memcpy;
    如果你不能保证是否有重叠,为了确保复制的正确性,你必须用memmove。
    memcpy的效率会比memmove高一些,两者的实现:

    void* memmove(void* dest, void* source, size_t count) 
    { 
        assert((dest!=NULL) && (source !=NULL)); 
        void* ret = dest; 
        if (dest <= source || dest >= (source + count)) 
        { 
        while (count --) 
           *dest++ = *source++; 
        } 
       else 
       { 
          dest += count - 1; 
          source += count - 1; 
          while (count--) 
             *dest-- = *source--;
      } 
      return ret; 
    }
    
    void* memcpy(void* dest, void* source, size_t count) 
    { 
       assert((dest!=NULL) && (source !=NULL)); 
       void* ret = dest; 
       while (count--) 
       *dest++ = *source; 
       return ret; 
    }

    对于字符串拷贝函数,strcpy()也是存在内存重叠问题的。

    展开全文
  • C语言内存重叠

    2018-05-12 20:07:01
    问题描述:内存重叠就是拷贝的目的地址和源地址有重叠。举一个简单例子:有数组str={1,2,3,4,5,6,7,8,9};现要求将后三个数移动到最前面我们需要进行的操作:1.创建一个临时数组保存要移动的数字(7,8...
  • C++内存泄漏和内存重叠的原因 内存泄漏: 已经失去作用的堆内存未被及时释放,从而造成内存的浪费 1. new、delete错误使用() new在堆区分配内存,却忘记通过delete释放; new申请二维数组,却只通过delete[] p释放...
  • C语言:内存重叠

    2017-10-27 13:37:36
    内存重叠:拷贝的目的地址在源地址范围内。所谓内存重叠就是拷贝的目的地址和源地址有重叠。 在函数strcpy和函数memcpy都没有对内存重叠做处理的,使用这两个函数的时候只有程序员自己保证源地址和目标地址不...
  • 关于strcpy函数的实现,防止内存重叠,memcpy本身具有防止内存重叠,此处为自己实现。防止内存重叠的方法就是高地址低地址逆序赋值即可避免。重叠的唯一情况是当t2向t1出拷贝,如果满足t1的首地址在t2的首地址到尾...
  • memcpy内存重叠的解决

    2018-12-22 22:57:18
    内存重叠:拷贝的目的地址在源地址范围内。所谓内存重叠就是拷贝的目的地址和源地址有重叠。 在函数strcpy和函数memcpy都没有对内存重叠做处理的,使用这两个函数的时候只有程序员自己保证源地址和目标地址不重叠,...
  • C++ 经典面试题memcpy考虑内存重叠情况.pdf
  • 内存重叠拷贝方法

    2020-03-26 14:58:23
    strcpy和memcpy函数对于第...memmove可以解决内存重叠问题。 void *memmove(void *dest, const void *src, size_t count) { char *tmp; const char *s; if (dest <= src) { tmp = dest; s = src; while (count...
  • 当使用memcpy时,存在内存重叠问题时可能会出错,memmove解决了此问题,解决问题的方法是当出现内存重叠时,从后往前开始拷贝,具体的memcpy和memmove参考博客:https://www.cnblogs.com/luoquan/p/5265273.html ...
  • memcpy 内存重叠问题

    千次阅读 2014-04-30 09:24:52
    凡是涉及cpy函数感觉都要考虑内存重叠问题,并且在重叠情况下考虑是前重叠
  • memcpy实现内存重叠的拷贝

    千次阅读 2019-03-17 16:18:40
    面试官叫我实现内存拷贝函数,同时问我出现了内存重叠怎么办? 什么叫内存重叠呢?我画个图 比如要拷贝src的4个字节到dest,那么就出现了内存重叠,如果从头开始拷贝,那么dest把src覆盖掉了。自己实现一款memcpy...
  • 什么是“内存重叠”? 当我们进行内存拷贝(memcpy函数)时,目标地址在原地址的范围内就造成了内存重叠。 这么说可能会比较抽象,下面我们借助于memcpy函数通过一个例子说明。 memcpy(void *dest, void *src, size_...
  • C++中的内存重叠问题

    2019-09-23 06:46:14
    内存重叠,直到做到一个笔试题才知道了什么是内存重叠。先上题目吧,是一个淘宝的笔试题,当时有点懵,不知道这个名词是啥子意思。 题目:补充下面函数代码: 如果两段内存重叠,用memcpy函数可能会导致行为...
  • strcpy及memcpy的内存重叠处理

    千次阅读 2018-09-30 17:48:49
    strcpy和memcpy同是一个类型的函数,但实质上却是不同的,他们的原型分别为:    char *strcpy(char *dest...当我们使用这两个函数时都会出现同样一个问题,内存重叠。那么我们就来分析一下内存重叠是如何产的。...
  • c语言学习之内存重叠

    2017-08-28 20:44:12
    遇到这样一个问题,当数组进行拷贝的时候,如果是在同一个数组内拷贝,就有可能出现内存重叠的问题,比如 #include void Copy(int *a, int *b,int len)//b从开始复制len个数字到a {  int i ; //为了更突出问题...
  • 话说上一节说到memcpy函数实现没有考虑内存重叠问题,难道C库函数故意留一个bug吗?当然不是了,memmove函数就弥补了这个不足哦,是不是以前一直觉得这两个函数没啥区别呢,实际上区别大了去了,下面详细道来。 ...
  • memmove 和 memcpy的区别以及处理内存重叠问题

    万次阅读 多人点赞 2016-05-15 19:30:16
    memmove 和 memcpy的区别以及处理内存重叠问题
  • C++中“内存重叠

    2017-07-31 10:51:31
    但是经过仔细分析后发现里面隐藏了一个知识点“内存重叠”,当然这个知识点也正是面试过程中面试官想要看到你是否注意到这个问题了。 接下来我就先简单介绍下什么是“内存重叠”? 当我们进行内存拷贝(memcpy函数)...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 76,953
精华内容 30,781
关键字:

内存重叠