memcpy

memcpy 内存拷贝函数 函数原型： void *memcpy(void *dst, const void *src, size_t n); 功能： 从src所指位置的地址为起始地址，拷贝n个字节到dst所指的内存地址的起始位置中 实现： void *my_memcpy( void *dst, const void *src, size_t n) { assert(dst != NULL && src != NULL ); char *p_dst = ( char *)dst; const char *p_src = ( const char *)src; while (n--) { p_dst++ = p_src++; } } 缺陷： 未考虑内存重叠等问题 memmove 功能： 与memcpy基本一致，但遭遇内存重叠仍可以正确进行 实现： void *my_memmove( char *dst, const char *src, size_t n) { assert(dst != NULL && src != NULL ); char *p_dst = ( char *)dst; const char *p_src = ( const char *)src; if (p_dst <= p_src || p_dst > (psrc + n)) { //不存在内存重叠，正常拷贝

测试代码： #include <memory.h> #include <string.h> #include <stdio.h> char string1[60] = "000001234567"; int main( void ) { fprintf(stderr, "%s:%d:%s, string1=%s leosu \n",__FILE__, __LINE__,__FUNCTION__, string1 ); memcpy(&string1[0], &string1[5],7); fprintf(stderr, "%s:%d:%s, string1=%s leosu \n",__FILE__, __LINE__,__FUNCTION__, string1 ); return 1; } leosu@leosu:/mnt/tmp/c_cplusplus_test$ gcc memcpy_test.cpp leosu@leosu:/mnt/tmp/c_cplusplus_test$ ./a.out memcpy_test.cpp:8:main, string1=000001234567 leosu memcpy_test.cpp:10:main, string1=123456734567 leosu 来源： CSDN 作者： bamboolsu 链接： https://blog

标准仿C语言 memset、memcpy、memmove函数 前段时间，移植了C的网络加解密算法到C#，其中遇到很多问题，核心问题大多都是字节拷贝问题，今天有时间整理了一下相关的API，废话不多说直接贴源码: (值得注意的是memmove函数，支持数据重叠，详情参照 http://blog.csdn.net/yujun_wu/article/details/4999565 ) 一> C++版 /* * @brief: 将dst中当前位置后面的 count 个字节用 val 替换并返回 dst * @param s - 数据内存的起始地址 * @param c - 替换后的值 * @param n - 要替换的长度 * @return 返回原数据首地址 */ void* memset(void* s, int c, size_t n) { assert(s); unsigned char* p = (unsigned char*)s; while (n > 0) { *p++ = (unsigned char)c; --n; } return s; } /* * @brief: 用于从src拷贝count个字节到dest，如果目标区域和源区域有重叠的话 ，memmove能够保证源串在被覆盖之前将重叠区域的字节拷贝到目标区域中。 但复制后src内容会被更改

包含头文件： ＃include <stdlib.h> 1>:malloc calloc realloc free函数 //动态内存分配函数 三个函数的声明分别是: void* malloc(unsigned size); malloc()函数有一个参数,即要分配的内存空间的大小: void* calloc(size_t nelem, size_t elsize); calloc()函数有两个参数,分别为元素的数目和每个元素的大小,这两个参数的乘积就是要分配的内存空间的大小。 如果调用成功,函数malloc()和函数calloc()都将返回所分配的内存空间的首地址。 malloc和calloc都可以分配内存区，但malloc一次只能申请一个内存区，calloc一次可以申请多个内存区．另外calloc会把分配来的内存区初试化为０，malloc不会进行初始化． void* realloc(void* ptr, unsigned newsize); realloc是给一个已经分配了地址的指针重新分配空间,参数ptr为原有的空间地址,newsize是重新申请的地址长度 free的调用形式为free(void*ptr)：释放ptr所指向的一块内存空间。 ＃i nclude <stdio.h> ＃i nclude <stdlib.h> main() { int *p=NULL; p=(int *

1. 以下哪个函数可以在源地址和目的地址的位置任意的情况下，在源地址和目的地址的空间大小任意的情况下实 现二进制代码块的复制？ memcpy、 memmove、 memset 、strcpy 解答： memmove 1) memcpy 函数原型 void *memcpy(void*dest, const void *src, size_t n); 功能 由src指向地址为起始地址的连续n个字节的数据复制到以dest指向地址为起始地址的空间内。 头文件 #include<string.h> 返回值 　　 函数返回一个指向dest的指针。 说明 　 　1. source和dest所指内存区域不能重叠 ，函数返回指向destin的指针。 　 　2.与strcpy相比，memcpy并不是遇到'\0'就结束，而是一定会拷贝完n个字节。 memcpy用来做内存拷贝，你可以拿它拷贝任何数据类型的对象，可以指定拷贝的数据长度； 例： char a[100], b[50]; memcpy(b, a,sizeof(b)); // 注意如用sizeof(a)，会造成b的内存地址溢出。 strcpy 就只能拷贝字符串了，它遇到'\0'就结束拷贝 ；例： char a[100], b[50]; strcpy(a,b); 　　3.如果目标数组destin本身已有数据，执行memcpy（）后，将覆盖原有数据

memcpy和memmove均为内存拷贝函数，原型分别为： void * memcpy ( void *dest, const void *src, size_t n); void *memmove( void *dest, const void *src, size_t n); 当拷贝的内存存在重叠区域时，memcpy可能会发生错误，而memmove不会发生。 下图为重叠情况剖析【绿色代表重叠区域】： 重叠情况（1）： 重叠情况（2）： 两个函数具体实现如下： void * memcpy ( void *dst, const void *src, size_t n) /*将src 的 n 字节拷贝到dst 内存中*/ { char *su1; const char *su2; for (su1 = dst, su2 = src; 0 < n; ++su1, ++su2, --n) { *su1 = *su2; } return dst; } void *memmove( void *dst, const void *src, size_t n) /*将scr 的 n 字节拷贝到dst 内存中*/ { char *sc1; const char *sc2; sc1 = dst; sc2 = src; if (sc2 < sc1 && sc1 < sc2 + n) { for

1.memcpy void * memcpy ( void * dest, const void * src, size_t num ) (1)函数memcpy从src的位置开始向后复制num个字节的数据到dest的内存位置。 (2)这个函数在遇到’\0’ 的时候并不会停下来。 (3)如果src和dest有任何的重叠，复制的结果都是未定义的 。 void *my_memcpy(void *dest, const void *src, size_t num) { char *str1 = (char *)dest;//应为此函数要将src的n个字节copy给dest char *str2 = (char *)src;//所以先强转为char* assert(dest != NULL && src != NULL);//使用assert断言，防止传空指针 while (num--) { *str1++ = *str2++;//切记不能把此条语句放入while()中,其他类型强转成char* }//时之间可能会存有'\0'的字节，会导致while的结束 return dest; } int main() { int ar[10] = { 1, 2, 3, 4 }; int ar2[10]; my_memcpy(ar2, ar, 4); printf("%d %d\n", ar2[0],

#include<stdio.h> #include<stdlib.h> #include<memory.h> void* my_memcpy(void* dest, void* src, int count) { char *my_dest = (char*)dest; char *my_src = (char*)src; if(dest == NULL || src == NULL) { return NULL; } while(count--) { *my_dest++ = *my_src++; } return dest; } int main() { char str[] = "helloworld"; char str1[] = "helloworld"; char str2[] = "helloworld"; char str3[]= "helloworld"; char str4[]= "helloworld"; char *dest, *src; int i = 1; src = str; dest = &str[2]; for(i; i <= 5; i++) { *dest++ = *src++; } memcpy(&str1[2],str1,5); memmove(&str2[2],str2,5); strncpy(&str3[2],str3,5); my

memcpy与memmove函数异同 memcpy memmove memset memcpy 函数原型 void * memcpy ( void * destination , const void * source , size_t num ) 头文件 < string . h > 作用：从源src所指的内存地址的起始位置开始拷贝num个字节到目标dest所指的内存地址的起始位置中。 注意： （1）memcpy是内存拷贝函数； （2）此函数不考虑类型，以字节为单位进行拷贝； （3）这个函数在遇到’\0’时不会停下来； （4）memcpy与strcpy功能有所重叠，但拷贝字符串一般使用strcpy，因为strcpy以’\0’结尾，更加专业安全。 模拟实现： # include <stdio.h> # include <windows.h> # include <assert.h> void * My_Memcpy ( void * dst , const void * src , int num ) { assert ( dst ) ; assert ( src ) ; char * dst_ = ( char * ) dst ; char * src_ = ( char * ) src ; while ( num ) { * dst_ = * src_ ; * dst_ ++

通过字符串的学习，我们知道字符串操作函数的操作对象是字符串，并且它的结束标志是结束符\0，当然这个说的是不 受限制的字符串函数。然而当我们想要将一段内存的数据复制到另一块内存时，我们不能使用字符串操作函数，当然也 不能一个一个复制，所以就引入了内存操作函数。 memcpy 函数原型： void *memcpy(void *dst, const void *src, size_t size); 将一块内存的数据复制到另一块内存。当两块内存重叠 的时候，memcpy就不能保证拷贝正确。 memmove 函数原型： void *memmove(void *dst, const void *src, size_t size); 可以拷贝内存重叠的，也可以拷贝不重叠的。 下面模拟实现memcpy函数： #define _CRT_SECURE_NO_WARNINGS 1 #include<stdio.h> #include<assert.h> void *my_memcpy(void *dest, const void *src, size_t size) { assert(dest); assert(src); char *str1 = (char *)dest; const char *str2 = (const char *)src; while (size) { *str1 =