[转]memmove函数

【FROM MSDN && 百科】

原型:  void *memmove( void* dest, const void* src, size_tcount );

#include<string.h>

由src所指内存区域复制count个字节到dest所指内存区域。

src和dest所指内存区域可以重叠,但复制后dest内容会被更改。函数返回指向dest的指针

Copies the values of num bytes from the location pointed by source to the memory block pointed by destination. Copying takes place as if an intermediate buffer were used, allowing the destination and source to overlap.

memmove的处理措施:

(1)当源内存的首地址等于目标内存的首地址时,不进行任何拷贝

(2)当源内存的首地址大于目标内存的首地址时,实行正向拷贝

(3)当源内存的首地址小于目标内存的首地址时,实行反向拷贝

//#define FIRST_DEMO
//#define SECOND_DEMO
#define MYMEMMOVE
#ifdef FIRST_DEMO
#include <stdio.h>
#include <conio.h>
#include <string.h>
int main(void)
{
    char s[]="Golden Global View";
    memmove(s,s+7,strlen(s)+1-7);//+1是取‘\0‘,可以去掉看下结果
    printf("%s\n",s);
    getch();
    return 0;
}
#elif defined SECOND_DEMO
#include <stdio.h>
#include <conio.h>
#include <string.h>
int main(void)
{
    char str1[7]="aabbcc";
    printf( "The string: %s\n", str1 );
    memcpy(str1+2,str1,4);
    printf( "New string: %s\n", str1 );
    memmove(str1+2,str1,4);
    printf( "New string: %s\n", str1 );
    getch();
    return 0;
}
/*output:
The string: aabbcc
New string: aaaabb
New string: aaaaaa
*/
#elif defined MYMEMMOVE
#include <stdio.h>
#include <conio.h>
#include <string.h>
#include <assert.h>
void *mymemmove(void *dest,const void *src,size_t coount);
int main(void)
{
    char str1[7]="aabbcc";
    mymemmove(str1+2,str1,4);
    puts(str1);
    getch();
    return 0;
}
void *mymemmove(void *dest,const void *src,size_t count)
{
    char *ret=(char *)dest;
    char *dest_t=dest;
    char *src_t=(char *)src;
    assert( NULL !=src && NULL !=dest);  

    if (dest_t<=src_t || dest_t>=src_t+count)
    {
        while(count--)
        {
            *dest_t++ = *src_t++;
        }
    }
    else
    {
        dest_t+=count-1;
        src_t+=count-1;
        while(count--)
        {
            *dest_t--=*src_t--;
        }
    }
    return ret;
}
#endif

  

时间: 2024-10-31 09:02:33

[转]memmove函数的相关文章

实现memcpy和memmove函数

题目: 自己定义一个函数,实现my_memcpy和my_memmove函数. 题目分析: memcpy函数主要实现的是内存的拷贝,函数接受任意类型的参数,并且有拷贝个数的限制,函数与strcpy函数在功能上有相似点,也有不同点.memmove函数在memcpy函数的基础上解决了内存重叠的问题.下面是memcpy和memmove函数的实现: my_memmove函数: #define _CRT_SECURE_NO_WARNINGS 1 #include <stdio.h> #include &l

C语言模拟实现memcpy,memmove函数

这里memcpy与memmove函数的模拟实现,需要用到空指针来传递参数,之后强制类型转换为char型,用size_t这个宏接受偏移量进行偏移,模拟实现如下: memcpy函数: void* my_memcpy(void*dst,const void*src ,size_t count) { assert(dst); assert(src); void* ret = dst; while (count--) { *(char*)dst = *(char*)src; dst = (char*)ds

【C语言】模拟实现memmove函数(考虑内存重叠)

//模拟实现memmove函数(考虑内存重叠) #include <stdio.h> #include <assert.h> #include <string.h> void * memmove(void * dst, const void * src, int count) { void * ret = dst; assert(dst); assert(src); if (dst <= src || (char *)dst >= ((char *)src

memcpy函数 和 memmove函数 原码

原型:extern void *memcpy(void *dest, void *src, unsigned int count); 用法:#include <string.h> 功能:由src所指内存区域复制count个字节到dest所指内存区域. 说明:src和dest所指内存区域不能重叠,函数返回指向dest的指针. 举例: // memcpy.c #include <syslib.h> #include <string.h> main() { char *s=&

C语言memcpy()函数和memmove()函数

C语言memcpy()函数和memmove()函数 关于 memcpy() 函数,请先看链接. memcpy() 函数和 memmove() 函数的函数原型如下: void* memcpy(void * restrict s1, const void * restrict s2, size_t n); void* memmove(void * s1, const void * s2, size_t n); 两函数作用相似,都是指针 s2 指向的区域拷贝 n 个字节至 s1 指向的区域,并且都返回

重写memmove函数

在内存复制的时候,如果两段内存有重叠,那么就很容易产生覆盖.所以重写这个函数,对有重叠的内存的拷贝进行处理. void* memmove(void* str1,const void* str2,int n) { char* pStr1 = (char*) str1; const char* pStr2 = (const char*)str2; if(pStr1 < pStr2) //从前面开始copy { for(int i=0; i!=n; ++i) { *(pStr1++) = *(pStr

模拟实现memmove函数

完成这道题目之前首先要明确memmove是对内存进行操作,所以函数的参数是void *,即可以操作任意类型的数据. 其次要明白两个待处理数据的关系,于是我画了一张图帮助大家理解上面的是特殊情况,发生内存重叠时只有这种情况是需要从右向左进行操作的,如果这种情况还是按照从左往右操作的话就会把想要拷贝的东西一直重复的拷贝下去,除这种情况之外都只需从左往右拷贝 再然后就是如何实现代码的过程了,其方法和之前说过的拷贝函数类似,进行值的交换,在这里就不详细赘述了. #define _CRT_SECURE_N

【C语言】【面试题】【笔试题】模拟实现数据库中memmove函数

#include <stdio.h> #include <stdlib.h> #include <assert.h> void *my_memmove(void *p1, const void *p2, size_t count) {     assert(p1);     assert(p2);     char *dest = (char*)p1;     char *src = (char*)p2;     dest = dest + 16;     src = 

memmove函数实现2

#include<stdio.h> #include<stdlib.h> typedef unsigned int uint; void* my_memmove(void* p,const void* q,uint len) {  void*ret=p;  char* p1=(char*)p;  char* q2=(char*)q;  if((p1>q2)&&(p1<q2+len))  {   while(len--)   {    *(p1+len-1