C++手动复制内存和使用memoryCopy（就是memcpy函数）相比会不会更慢

memcpy函数用法memcpy指的是c和c++使用的内存拷贝函数，memcpy函数的功能是从源内存地址的起始位置开始拷贝若干个字节到目标内存地址中。函数原型void *memcpy(void *dest, const void *src, size_t n);折叠编辑本段功能从源src所指的内存地址的起始位置开始拷贝n个字节到目标dest所指的内存地址的起始位置中折叠编辑本段所需头文件C语言:#include<string.h>C++:#include<cstring>折叠编辑本段返回值函数返回指向dest的指针。折叠编辑本段说明1.source和destin所指的内存区域可能重叠，但是如果source和destin所指的内存区域重叠,那么这个函数并不能够确保source所在重叠区域在拷贝之前不被覆盖。而使用memmove可以用来处理重叠区域。函数返回指向destin的指针.2.如果目标数组destin本身已有数据，执行memcpy()后，将覆盖原有数据(最多覆盖n)。如果要追加数据，则每次执行memcpy后，要将目标数组地址增加到你要追加数据的地址。注意:source和destin都不一定是数组，任意的可读写的空间均可。折叠编辑本段函数实现Windows中coreutils中Linux中:折叠编辑本段程序实例程序例example1作用:将s中的字符串复制到字符数组d中。输出结果:Golden Global Viewexample2作用:将s中第13个字符开始的4个连续字符复制到d中。(从0开始)输出结果: Viewexample3作用:复制后覆盖原有部分数据输出结果:destination before memcpy:abcdefghijlkmnopqrstuvwxyz0123as6destination after memcpy: ******************************as6strcpy和memcpy主要有以下3方面的区别。1、复制的内容不同。strcpy只能复制字符串，而memcpy可以复制任意内容，例如字符数组、整型、结构体、类等。2、复制的方法不同。strcpy不需要指定长度，它遇到被复制字符的串结束符""才结束，所以容易溢出。memcpy则是根据其第3个参数决定复制的长度。3、用途不同。通常在复制字符串时用strcpy，而需要复制其他类型数据时则一般用memcpy

memcpy指的是c和c++使用的内存拷贝函数，memcpy函数的功能是从源src所指的内存地址的起始位置开始拷贝n个字节到目标dest所指的内存地址的起始位置中。Windows中123456789101112131415161718192021222324void* __cdecl memcpy(void* dst,const void* src,size_t count){void*ret=dst;#if defined(_M_MRX000)||defined(_M_ALPHA)||defined(_M_PPC){extern void RtlMoveMemory(void *,const void *,size_t count);RtlMoveMemory(dst,src,count);}#else /*defined(_M_MRX000)||defined(_M_ALPHA)||defined(_M_PPC)*//**copy from lower addresses to higher addresses*/while(count--){*(char *)dst = *(char *)src;dst = (char *)dst+1;src = (char *)src+1;}#endif /*defined(_M_MRX000)||defined(_M_ALPHA)||defined(_M_PPC)*/return (ret);}coreutils中12345678910void* memcpy(void*destaddr,voidconst*srcaddr,size_tlen){char* dest=destaddr;char const* src=srcaddr;while(len-->0){*dest++ = *src++;}return destaddr;}Linux中：123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869void *memcpy(void *to, const void *from, size_t n){void *xto = to;size_t temp, temp1;if (!n)return xto;if ((long)to & 1) {char *cto = to;const char *cfrom = from;*cto++ = *cfrom++;to = cto;from = cfrom;n--;}if (n > 2 && (long)to & 2) {short *sto = to;const short *sfrom = from;*sto++ = *sfrom++;to = sto;from = sfrom;n -= 2;}temp = n >> 2;if (temp) {long *lto = to;const long *lfrom = from;#if defined(CONFIG_M68000) || defined(CONFIG_COLDFIRE)for (; temp; temp--)*lto++ = *lfrom++;#elseasm volatile (" movel %2,%3 "" andw #7,%3 "" lsrl #3,%2 "" negw %3 "" jmp %%pc@(1f,%3:w:2) ""4: movel %0@+,%1@+ "" movel %0@+,%1@+ "" movel %0@+,%1@+ "" movel %0@+,%1@+ "" movel %0@+,%1@+ "" movel %0@+,%1@+ "" movel %0@+,%1@+ "" movel %0@+,%1@+ ""1: dbra %2,4b "" clrw %2 "" subql #1,%2 "" jpl 4b": "=a" (lfrom), "=a" (lto), "=d" (temp), "=&d" (temp1): "0" (lfrom), "1" (lto), "2" (temp));#endifto = lto;from = lfrom;}if (n & 2) {short *sto = to;const short *sfrom = from;*sto++ = *sfrom++;to = sto;from = sfrom;}if (n & 1) {char *cto = to;const char *cfrom = from;*cto = *cfrom;}return xto;}程序例example1作用：将s中的字符串复制到字符数组d中。12345678910111213//memcpy.c#include <stdio.h>#include <string.h>int main(){char* s="GoldenGlobalView";char d[20];clrscr();memcpy(d,s,(strlen(s)+1));printf("%s",d);getchar();return 0;}输出结果：Golden Global Viewexample2作用：将s中第13个字符开始的4个连续字符复制到d中。(从0开始)1234567891011#include<string.h>int main({char* s="GoldenGlobalView";char d[20];memcpy(d,s+12,4);//从第13个字符(V)开始复制，连续复制4个字符(View)d[4]="";//memcpy(d,s+12*sizeof(char),4*sizeof(char));也可printf("%s",d);getchar();return 0;}输出结果：　Viewexample3作用：复制后覆盖原有部分数据1234567891011#include<stdio.h>#include<string.h>int main(void){char src[]="******************************";char dest[]="abcdefghijlkmnopqrstuvwxyz0123as6";printf("destination before memcpy:%s ",dest);memcpy(dest,src,strlen(src));printf("destination after memcpy:%s ",dest);return 0;}输出结果：destination before memcpy:abcdefghijlkmnopqrstuvwxyz0123as6destination after memcpy: ******************************as6

这些问题,MSDN啦,标准库的函数里面都有

strcpy和memcpy都是标准C库函数，它们有下面的特点。strcpy提供了字符串的复制。即strcpy只用于字符串复制，并且它不仅复制字符串内容之外，还会复制字符串的结束符。已知strcpy函数的原型是：char* strcpy(char* dest, const char* src);memcpy提供了一般内存的复制。即memcpy对于需要复制的内容没有限制，因此用途更广。void *memcpy( void *dest, const void *src, size_t count );char * strcpy(char * dest, const char * src) // 实现src到dest的复制{if ((src == NULL) || (dest == NULL)) //判断参数src和dest的有效性{return NULL;}char *strdest = dest; //保存目标字符串的首地址while ((*strDest++ = *strSrc++)!=""); //把src字符串的内容复制到dest下return strdest;}void *memcpy(void *memTo, const void *memFrom, size_t size){if((memTo == NULL) || (memFrom == NULL)) //memTo和memFrom必须有效return NULL;char *tempFrom = (char *)memFrom; //保存memFrom首地址char *tempTo = (char *)memTo; //保存memTo首地址 while(size -- > 0) //循环size次，复制memFrom的值到memTo中*tempTo++ = *tempFrom++ ; return memTo;}strcpy和memcpy主要有以下3方面的区别。1、复制的内容不同。strcpy只能复制字符串，而memcpy可以复制任意内容，例如字符数组、整型、结构体、类等。2、复制的方法不同。strcpy不需要指定长度，它遇到被复制字符的串结束符""才结束，所以容易溢出。memcpy则是根据其第3个参数决定复制的长度。3、用途不同。通常在复制字符串时用strcpy，而需要复制其他类型数据时则一般用memcpy

区别：memcpy和memmove（）都是C语言中的库函数，在头文件string.h中，作用是拷贝一定长度的内存的内容，原型分别如下：[cpp] view plain copyvoid *memcpy(void *dst, const void *src, size_t count);void *memmove(void *dst, const void *src, size_t count);他们的作用是一样的，唯一的区别是，当内存发生局部重叠的时候，memmove保证拷贝的结果是正确的，memcpy不保证拷贝的结果的正确。

具体代码时啥样子？你怎么“加”的头文件？

memcpy和memmove（）都是C语言中的库函数，在头文件string.h中，作用是拷贝一定长度的内存的内容，原型分别如下：void *memcpy(void *dst, const void *src, size_t count);void *memmove(void *dst, const void *src, size_t count); 他们的作用是一样的，唯一的区别是，当内存发生局部重叠的时候，memmove保证拷贝的结果是正确的，memcpy不保证拷贝的结果的正确。二者的c语言实现很简单，有兴趣的朋友可以去看看。在实际情况下，这两个函数都是用汇编实现的。memmove在copy两个有重叠区域的内存时可以保证copy的正确，而memcopy就不行了，但memcopy比memmove的速度要快一些，如：char s[] = "1234567890";char* p1 = s;char* p2 = s+2;memcpy(p2, p1, 5)与memmove(p2, p1, 5)的结果就可能是不同的，memmove()可以将p1的头5个字符"12345"正确拷贝至p2，而memcpy()的结果就不一定正确了.和memcpy相比，src和des有重叠的情况下，memmove可以保证数据的完整性.memmove保证的原因很简单，就是针对重叠的情况做特殊处理，因此速度会比memcpy慢一些具体的算法并不难想，画个图，分两种情况 1. src的尾部和des的头部重合从src尾部开始，以地址 -- 的方式copy到des2. src的头部和des的尾部重合从src头部开始，以地址 ++ 的方式copy到des

c和c++使用的内存拷贝函数，memcpy函数的功能是从源src所指的内存地址的起始位置开始拷贝n个字节到目标dest所指的内存地址的起始位置中。功能：从源src所指的内存地址的起始位置开始拷贝n个字节到目标dest所指的内存地址的起始位置中1.source...

语法: #include <string.h> int memcmp( const void *buffer1, const void *buffer2, size_t count ); 功能：函数比较buffer1 和 buffer2的前count 个字符。返回值如下:Value 解释 less than 0 buffer1 is less than buffer2 equal to 0 buffer1 is equal to buffer2 greater than 0 buffer1 is greater than buffer2 相关主题:memchr(), memcpy(), and strcmp().memcpy语法: #include <string.h> void *memcpy( void *to, const void *from, size_t count ); 功能：函数从from中复制count 个字符到to中，并返回to指针。 如果to 和 from 重叠，则函数行为不确定。

memset函数用来对一段内存空间全部设置为某个字符,常用于内存空间初始化。将已开辟内存空间s的首n个字节的值设为值c。下面是一个例子#include<stdio.h>#include<string.h>main(){char*s="GoldenGlobalView";clrscr();memset(s,"G",6);printf("%s",s);getchar();return0;}C语言memcpy函数原型：externvoid*memcpy(void*dest,void*src,unsignedintcount);用法：#include<string.h>功能：由src所指内存区域复制count个字节到dest所指内存区域。说明：src和dest所指内存区域不能重叠，函数返回指向dest的指针。举例：//memcpy.c#include<syslib.h>#include<string.h>main(){char*s="GoldenGlobalView";chard[20];clrscr();memcpy(d,s,strlen(s));d[strlen(s)]=0;printf("%s",d);getchar();return0;}函数strchr()功能:在一个串中查找给定字符的第一个匹配之处用法:char*strchr(char*str,charc);程序例:#include#includeintmain(void){charstring[15];char*ptr,c="r";strcpy(string,"Thisisastring");ptr=strchr(string,c);if(ptr)printf("Thecharacter%cisatposition:%d ",c,ptr-string);elseprintf("Thecharacterwasnotfound ");return0;}

用 unsined char buf[4];for(int i=0;i<=3;i++)printf(printf("%x ",buf[i]); 你试试看哦

strcpy是按字符串的长度进行拷贝，而memcpy是按指定的字节数进行拷贝。打个比方，charstr[20]是一个最多可以装下20个字符的串，但实际它的值是"abcde"5个字符，那么你用strcpy得到的就是一个只有6个字符的串（包括最后的""），相当于chars[6]。而你使用memcpy，指定拷贝20个字节，那么你就可以得到比"abcde"更长的内容，包括后面的也会拷贝过去。

c和c++使用的内存拷贝函数，memcpy函数的功能是从源src所指的内存地址的起始位置开始拷贝n个字节到目标dest所指的内存地址的起始位置中。功能：从源src所指的内存地址的起始位置开始拷贝n个字节到目标dest所指的内存地址的起始位置中1.source和destin所指的内存区域可能重叠，但是如果source和destin所指的内存区域重叠,那么这个函数并不能够确保source所在重叠区域在拷贝之前不被覆盖。而使用memmove可以用来处理重叠区域。函数返回指向destin的指针.2.如果目标数组destin本身已有数据，执行memcpy（）后，将覆盖原有数据（最多覆盖n）。如果要追加数据，则每次执行memcpy后，要将目标数组地址增加到你要追加数据的地址。strncpy是C语言的库函数之一，来自C语言标准库，定义于string.h，char*strncpy(char*dest,char*src,intn)，把src所指向的字符串中以src地址开始的前n个字节复制到dest所指的数组中，并返回dest。功能：（c/c++）复制字符串src中的内容（字符，数字、汉字.）到字符串dest中，复制多少由size_tn的值决定。如果src的前n个字节不含NULL字符，则结果不会以NULL字符结束。如果src的长度小于n个字节，则以NULL填充dest直到复制完n个字节。src和dest所指内存区域不可以重叠且dest必须有足够的空间来容纳src的字符长度+""。

转义符x00==0x00，语句含义：将内存地址0x00 0x00 0x00 0x00 的内容拷贝4字节至变量cschar

有两种方法可以实现。为方便说明，定义两个整型数组a,b，并实现将a中的值赋值到b中。int a[4] = {1,2,3,4}, b[4];1、 通过数组遍历，逐个赋值。定义循环变量int i;for(i = 0; i < 4; i ++)b[i] = a[i];该程序功能为遍历数组a，逐个赋值到数组b对应元素中。2、 借助内存复制函数memcpy，整体赋值。void *memcpy(void *dst, void *src, size_t size);这个函数的功能为将src上，大小为size字节的数据赋值到dst上。调用该函数时需要引用头文件cstring,即#include <cstring>赋值数组的代码为memcpy(b,a,sizeof(a));

自己看着修改一下就ok了， 。。。/*预先将参加抽奖者的资料输入存储起来，主要用结构体数组实现，用结构体表示每项记录，包括身份证号码、姓名、电话、住址等信息。开始抽奖时，屏幕上快速闪动参与者的身份证号码，按任意键停止闪动，把中奖人的信息用显示在屏幕上。可反复抽出一、二、三等奖若干名。设计实现以下功能：（1）录入：完成抽奖者信息的输入；（2）删除：完成抽奖者信息的删除；（3）修改：允许对已经录入的数据重新进行编辑、修改；（4）显示：显示所有中奖者的信息；（5）抽奖：a. 抽出一等奖 1 名，如果抽过就不能再抽；b. 抽出二等奖 2 名，如果抽完就不能再抽；c. 抽出三等奖 5 名，如果抽完就不能再抽；（6）退出程序。*/#include<stdio.h>#include <conio.h>#include <stdlib.h>#include <memory.h>#include <string.h>#include <time.h>#define AWARDER_NUM 10typedef struct tag_award { char ID[20]; char name[20]; char telNo[20]; char address[50];}AWARDER;AWARDER * awarder = new AWARDER[AWARDER_NUM];int first_award[1] = {-1};int second_award[2] = {-1,-1};int third_award[5] ={-1,-1,-1,-1,-1};int awarder_num = 0;void info_login(){ if(awarder_num >= AWARDER_NUM) { AWARDER * new_awarder = new AWARDER[awarder_num + AWARDER_NUM]; memcpy(new_awarder,awarder,awarder_num*sizeof(AWARDER)); delete awarder; awarder = new_awarder; } printf("身份证号："); scanf("%s",awarder[awarder_num].ID); printf("姓名："); scanf("%s",awarder[awarder_num].name); printf("电话号码："); scanf("%s",awarder[awarder_num].telNo); printf("家庭住址："); scanf("%s",awarder[awarder_num].address); awarder_num++;}void info_delete(){ char name[20]; printf("输入您要删除的抽奖者的姓名："); scanf("%s",name); for(int i=0;i<awarder_num;i++) { if (strcmp(awarder[i].name,name) == 0) { printf("您选择删除的抽奖者的信息如下： "); printf("身份证号：%s ",awarder[i].ID); printf("姓名：%s ",awarder[i].name); printf("电话号码：%s ",awarder[i].telNo); printf("家庭住址：%s ",awarder[i].address); break; } } if(i == awarder_num) { printf("没有找到您输入的抽奖者！ "); } else { char c; printf("您确定要删除吗？(Y//N)"); fflush(stdin); scanf("%c",&c); if(c == "Y" || c == "y") { AWARDER * new_award = new AWARDER[awarder_num-1]; if(i <= 0) memcpy(new_award,awarder+1,sizeof(AWARDER) * (awarder_num - 1)); else if( i >= awarder_num -1) memcpy(new_award,awarder,sizeof(AWARDER) * (awarder_num - 1)); else { memcpy(new_award,awarder,sizeof(AWARDER) * i); memcpy(new_award+i,awarder+i+1,sizeof(AWARDER) * (awarder_num - i - 1)); } awarder_num--; delete awarder; awarder = new_award; } }}void info_modify(){ char name[20]; printf("输入您要修改的抽奖者的姓名："); scanf("%s",name); for(int i=0;i<awarder_num;i++) { if (strcmp(awarder[i].name,name) == 0) { printf("您选择的抽奖者的信息如下： "); printf("身份证号：%s ",awarder[i].ID); printf("姓名：%s ",awarder[i].name); printf("电话号码：%s ",awarder[i].telNo); printf("家庭住址：%s ",awarder[i].address); break; } } if(i == awarder_num) { printf("没有找到您输入的抽奖者！ "); } else { printf("请输入该抽奖者的新信息： "); printf("身份证号："); scanf("%s",awarder[i].ID); printf("姓名："); scanf("%s",awarder[i].name); printf("电话号码："); scanf("%s",awarder[i].telNo); printf("家庭住址："); scanf("%s",awarder[i].address); }}bool check_over(int cur_award,int awarderNo){ if(awarderNo == 1) { if(cur_award == first_award[0]) return true; } else if(awarderNo <= 3) { if(cur_award == first_award[0]) return true; for(int i=0;i<awarderNo-1;i++) if(cur_award == second_award[i]) return true; } else if(awarderNo <= 8) { if(cur_award == first_award[0]) return true; for(int i=0;i<2;i++) if(cur_award == second_award[i]) return true; for(i=0;i<awarderNo-3;i++) if(cur_award == third_award[i]) return true; } return false;}void award(){ if(awarder_num < 8) { printf("人数太少，请添加足够的人再抽奖！ "); return; } srand((long)time(0)); char hit_id[20]; printf(" 开始抽第一等奖（1名），按任意键开始... "); getch(); while(!kbhit()) { first_award[0] = rand() % awarder_num; memcpy(hit_id,awarder[first_award[0]].ID,18); printf(" "); printf(" %s",hit_id); } printf(" 开始抽第二等奖（2名）"); for (int i=0;i<2;i++) { printf(" 第%d个二等奖,按任意键开始... ",i+1); getch(); while(!kbhit()) { second_award[i] = rand() % awarder_num; while(check_over(second_award[i],1+i)) second_award[i] = rand() % awarder_num; memcpy(hit_id,awarder[second_award[i]].ID,18); printf(" "); printf(" %s",hit_id); } } printf(" 开始抽第三等奖（5名）"); for (i=0;i<5;i++) { printf(" 第%d个三等奖,按任意键开始... ",i+1); getch(); while(!kbhit()) { third_award[i] = rand() % awarder_num; while(check_over(third_award[i],3+i)) third_award[i] = rand() % awarder_num; memcpy(hit_id,awarder[third_award[i]].ID,20); printf(" "); printf(" %s",hit_id); } }}void info_show(){ printf("一等奖获得者： "); printf(" 身份证号：%s ",awarder[first_award[0]].ID); printf(" 姓名：%s ",awarder[first_award[0]].name); printf(" 电话号码：%s ",awarder[first_award[0]].telNo); printf(" 家庭住址：%s ",awarder[first_award[0]].address); printf("二等奖获得者： "); for (int i=0;i<2;i++) { printf("第%d个二等奖获得者： "); printf(" 身份证号：%s ",awarder[second_award[i]].ID); printf(" 姓名：%s ",awarder[second_award[i]].name); printf(" 电话号码：%s ",awarder[second_award[i]].telNo); printf(" 家庭住址：%s ",awarder[second_award[i]].address); } printf("三等奖获得者： "); for (int i=0;i<5;i++) { printf("第%d个三等奖获得者： "); printf(" 身份证号：%s ",awarder[third_award[i]].ID); printf(" 姓名：%s ",awarder[third_award[i]].name); printf(" 电话号码：%s ",awarder[third_award[i]].telNo); printf(" 家庭住址：%s ",awarder[third_award[i]].address); }}/*提示信息*/bool raise(){ printf(" 请输入你需要的操作代号： "); printf(" 1.录入：完成抽奖者信息的输入; "); printf(" 2.删除：完成抽奖者信息的删除; "); printf(" 3.修改：允许对已经录入的数据重新进行编辑、修改; "); printf(" 4.抽奖：开始抽奖！ "); printf(" 5.显示：显示所有中奖者的信息; "); printf(" 6.退出。 "); printf("==>"); int operate; fflush(stdin); scanf("%d",&operate); switch(operate) { case 1: info_login(); break; case 2: info_delete(); break; case 3: info_modify(); break; case 4: award(); break; case 5: info_show(); break; case 6: return false; default: break; } printf(" 操作完成。 "); return true;}void main(){ while(raise());}

虚心学习各位答案，顶帖留签。

可能会有对齐的问题，在代码里加上#pragma pack (1)

看你那代码象API HOOK方面的->都不知道先学学基础吧现在的年轻人啊

strlen计算字符串中第一个ascii 0之前的字符个数，x[0]赋值0，也就是字符串的结束标志，所以长度为0

从实际的结果上来说，它应该是有一个缓冲区换句话说，有一个temp先把要拷贝的内容拷贝到temp中，然后再拷贝到你指定的内存区域

请问cc是什么？数组or指针？楼主你可知道sizeof（任何指针）在32位机器下面 结果永远是4吗？

应该是memcpy(dst,src,size_t len);这就没问题了。memcpy的第三个参数也就是len，必须是无符号的，而你定义的却是int len，所以不对 ，前面也是size_t len = 16

二维数组如果是一行一行存的话会把那些一行一行的复制过去，二维指针的话会把指针复制过去，每条指针指向的数组要单独复制。

不好意思看错了。

用 法: void *memcpy(void *destin, void *source, unsigned n); 功 能: 从源source中拷贝n个字节到目标destin中 类型得一样！

char array[sizeof（float）]；float value=1.234；memcpy（（void*）s，（void*）&value，sizeof（float））；

memset( &StructObj,0,sizeof(StructType));memcpy(dstbuf,srcbuf,size);

#include <stdio.h>main(){char src[]="*******S";char dest[200]="abcde"; // 这个数组要足够大int i,k;k = strlen(src);memcpy(&dest[k],dest,strlen(dest)); // 老内容后移memcpy(dest,src,k); //前面加新内容printf("%s",dest); // 成功了}

python标准库里有copy模块，该模块提供了2个方法，一个是copy浅拷贝，另一个是deepcopy深拷贝，所以你需要使用c/c++里的memcpy，你就要用deepcopy

你确定要用memcpy操作汉字？memcpy函数是用来操作ASCII字符的，汉字不在ASCII范围内。另外不同的编译器给一个汉字的内存空间是不一样的，比如我的编译环境，我定义一个char *s = "你好"，占用5个字节，若使用memcpy(dest,s,2)就会出现乱码，只有当memcpy的第三个参数大于等于5时才会拷贝成功。

弱弱的问：啥是深度复制？

给那个函数声明成这个父函数的友元函数试试

memcpy函数是对内存操作，在这期间，如果发生中断，进入中断服务程序，那么可能会造成数据混乱。或者破坏时序，打断memcpy的操作进程。

memcpy的效率会比memmove高一些，如果还不明白的话可以看一些两者的实现，平时很少有重叠的例子，所以只有特殊情况才考虑memmovevoid *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;}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;}

memcpy函数第二个参数是要copy到的地址,即目的地址.你看你的原始数据都放在第一个参数处了吧!第一次调用pbInBuff放一个字节后第二次调用就从下一个位置起开始放也就是pbInBuff+1再次调用就从再下个位置放即是从pbInBuff+2开始,这次放了2个字节最后当然是从pbInBuff+4开始放了,这次把实际数据长度全放进来虽然我不知道你具体实现的是什么,但看的出来,前三个放的是数据的头部,最后放的是实际有用的数据.

memcpy 是最好的方式，你是想找更快的方式，还是想找一个替代的方法，不计较性能？

可以的，在string.h头文件里面！

1：区别memcpy可以拷贝任何数据类型的对象，指定拷贝的数据长度。strcpy只能拷贝字符串了，它遇到""就结束拷贝memcpy()充分利用了机器字长为32位的特性(32位系统，一次内存读/写可操作4字节的数据， 对于64位系统，则一次可操作8字节数据)。先按4字节一组(movsl)拷贝，共复制n/4次；对剩下的零头再逐字节拷贝。如果支持，memcpy()还可以使用了MMX/SSE指令增加一次操作中的字节数，进一步提高效率。3：健壮性拷贝的缓冲区如果是非字符串，尽量用memcpy()，其实字符串使用memcpy也是很好的选择。你说的溢出可能是使用strcpy的结束问题或者是用memcpy指定的拷贝长度不对造成的

　　使用memcpy即可， 比如你另外建立一个结构体sortbook[1000]用来保存排序结果，将book中的第i个元素赋值到sortbook的第j个元素中memcpy(&sortbook[j], &book[i], sizeof(struct book));用这个函数需要#include <string.h>　　函数原型　　void *memcpy(void*dest, const void *src, size_t n);　　功能　　由src指向地址为起始地址的连续n个字节的数据复制到以destin指向地址为起始地址的空间内。　　头文件　　#include<string.h>　　返回值　　函数返回一个指向dest的指针。　　说明　　1.source和destin所指内存区域不能重叠，函数返回指向destin的指针。　　2.与strcpy相比，memcpy并不是遇到""就结束，而是一定会拷贝完n个字节。　　memcpy用来做内存拷贝，你可以拿它拷贝任何数据类型的对象，可以指定拷贝的数据长度；　　例：　　char a[100], b[50];　　memcpy(b, a,sizeof(b)); //注意如用sizeof(a)，会造成b的内存地址溢出。　　strcpy就只能拷贝字符串了，它遇到""就结束拷贝；例：　　char a[100], b[50];　　strcpy(a,b);　　3.如果目标数组destin本身已有数据，执行memcpy（）后，将覆盖原有数据（最多覆盖n）。如果要追加数据，则每次执行memcpy后，要将目标数组地址增加到你要追加数据的地址。　　//注意，source和destin都不一定是数组，任意的可读写的空间均可。u200d

可能速度上有区别吧，memcpy应该最快

s复制给d，并返回d地址

你需要声明 char hello[3][3]； 或要声明 char *hello[3]={"12","34","56"}; 这样 hello 才有字符串存放单元。不要定义为 中文字符“一二”“三四”“五六”，中文字符 一个字至少要占2个字节，[3] 搁不下 2个中文字。 另外，你的编译器必须支持中文才行。中文编码繁杂，初学c语言者 不值得花时间 到中文上去，它们是2种学问。例子程序如下：#include <stdio.h> main(){int i;char *hello[3]={"12","34","56"};for (i=0;i<3;i++) puts(hello[i]); puts("----");strcpy(hello[2],"mm"); //改变 "56" 成 mmfor (i=0;i<3;i++) puts(hello[i]); puts("----");memcpy(hello[1],"gg",3); //改变 34 成 ggfor (i=0;i<3;i++) puts(hello[i]); puts("----");return 0; }

【问题描述】：电脑重启后，设备和打印机中的打印机消失，并且无法使用打印机，但每次重新安装驱动后又可以使用。（如图1）图1【原因分析】：Print Spooler—文件打印服务启动类型设置为手动导致【简易步骤】：【我的电脑】—右键—【管理】—【服务和应用程序】—【服务】—【print spooler服务】—服务状态【停止】—启动类型【向下三角】—【自动】—【启动】—【确定】【解决方案】：1. 点击我的电脑右键管理。（如图2）图22. 点击【服务和应用程序】，双击【服务】。（如图3）图33. 找到【print spooler服务】，服务状态，点击【停止】。（如图4）图44. 启动类型中点击【向下三角】，选择【自动】，点击【启动】，点击【确定】。（如图5）图5注意事项：当此服务设置为禁用状态，打印机同样无法使用，并且无法安装打印机。

请教，1、对于memcpy(buf1,buf2,10)的内容怎么去掉buf1的前后空格？2、对于buf1，去掉空格后怎么转换成int型？此时buf1的内容一定是整型数值，不用考虑是否不是整型3、怎样判断buf1去掉前后空格后，buf1的内容是否以"ABC"开头，比如 "ABC123" 或者"ABCS9"等谢谢------解决方案--------------------#include <string.h>#include <ctype.h>char *trim(char *str){char *p = str;char *p1;if(p){p1 = p + strlen(str) - 1;while(*p && isspace(*p)) p++;while(p1 > p && isspace(*p1)) *p1-- = "";}return p;}调用：trim(buf1）------解决方案--------------------1、对于memcpy(buf1,buf2,10)的内容怎么去掉buf1的前后空格？最简单的：buf1[10]=0;2、对于buf1，去掉空格后怎么转换成int型？此时buf1的内容一定是整型数值，不用考虑是否不是整型使用函数 atoi/atof等3、怎样判断buf1去掉前后空格后，buf1的内容是否以"ABC"开头，比如 "ABC123" 或者"ABCS9"等使用strstr函数------解决方案--------------------boost::trim(str);------解决方案--------------------引用:Quote: 引用:楼主到底要干吗，是不是就想把 buf1 转换成数字？buf1的内容会不同，不同的地址COPy过来的，可以实现知道肯定是数字等，如果事先知道是数字，就转成inttry this.#include <algorithm>#include <cctype>#include <cstdlib>#include <cstring>#include <iostream>int main (){auto const buf = "will be skipped.123456789.it does not matter";auto const len = std::strlen(buf)+1;// look for first character that is a digital character.auto const found = std::find_if(buf,buf+len,::isdigit);if (buf+len != found){// if found, convert the following into a number,// taking as many characters as possible// without invalidating a number"s construct.std::cout << std::atoi(found) << std::endl;}}------解决方案--------------------引用:Quote: 引用:1、对于memcpy(buf1,buf2,10)的内容怎么去掉buf1的前后空格？最简单的：buf1[10]=0;2、对于buf1，去掉空格后怎么转换成int型？此时buf1的内容一定是整型数值，不用考虑是否不是整型使用函数 atoi/atof等3、怎样判断buf1去掉前后空格后，buf1的内容是否以"ABC"开头，比如 "ABC123" 或者"ABCS9"等使用strstr函数buf1是个指针啊指针和数组本质是一样，在大部分场合可以互用------解决方案--------------------不会用sscanf吗？#include <stdio.h>char s[]="123 ab 4";char *p;int v,n,k;void main() {p=s;while (1) {k=sscanf(p,"%d%n",&v,&n);printf("k,v,n=%d,%d,%d ",k,v,n);if (1==k) {p+=n;} else if (0==k) {printf("skip char[%c] ",p[0]);p++;} else {//EOF==kbreak;}}printf("End. ");}//k,v,n=1,123,3//k,v,n=0,123,3//skip char[ ]//k,v,n=0,123,3//skip char[a]//k,v,n=0,123,3//skip char[b]//k,v,n=1,4,2//k,v,n=-1,4,2//End.------解决方案--------------------引用:不会用sscanf吗？#include <stdio.h>char s[]="123 ab 4";char *p;int v,n,k;void main() {p=s;while (1) {

memcpy不管你传入的指针, 只是固定的赋值.作为一个函数, 它没办法做到传入的指针的原始属性.而你在调用的时候, 又做了强制转换, 于是调用时的编译器判断也被你绕过去了.从而导致一切正常.更重要的是, new出来的空间,本身就是可以赋值的, 并没有const属性, 这个属性是你强加的, 又强行去掉, 自然就一切正常了. 如果你改成const char *str ="1234567890";这个是系统赋予的const属性, 强制memcpy也可以通过编译, 但运行就会挂掉了.PS:你目前的代码是存在越界的. const char *str = new char(20);char *ch = new char(10);小括号应该是中括号 即const char *str = new char[20];char *ch = new char[10];目前的代码 只是分配了一个字符空间, 初始化为括号里面的值.

memcpy就是内存拷贝，从lpStreamBUf拷贝length个字节到lpdatain中对应C#就是byte数组的copy，具体函数我忘了lpdatain的最大值就是2000 * 2000 * 4 + 5120

modelData 10个字节，modelDest 5个字节，在这里用memcpy进行复制不是个好的主意。我暂时没想到有什么比手动完成要方便的方法。<pre t="code" l="cpp">for ( int i = 0; i < 5; ++i )modelDest[i] = (BYTE)modelData[i];

有点意思.FP_CMD_LENGTH的值是8?pucCmd申请的空间是多少？我怀疑是pucCmd的长度可能是　1-----pucCmd的定义是uint8_t* 还是uint8_t[8] ?如果是前者，则改用数组方式试一下。从跟踪情况看，感觉是此变量的长度不足造成的。

下面程序执行：读入二维数组 行数 列数 要求动态分配输入数组数据按行列输出数据按转置形式输出数据。#include <iostream>using namespace std;#include <stdio.h>main(){int NR,NC,i,j;int **a;cout << "input row col"<<endl;cin >> NR; //输入行数cin >> NC; //输入列数// 动态分配a = (int **) malloc(sizeof(int *) * NR);for (j=0;j<NR;j++){a[j] = (int *) malloc(sizeof(int) * NC);}// 输入二维数组数据cout << "input "<< NR << "*" << NC << " data"<<endl;for (j=0;j<NR;j++) for (i=0;i<NC;i++) cin>>a[j][i];// 显示原二维数组数据cout << "Original matrix a:" << endl;for (j=0;j<NR;j++) {for (i=0;i<NC;i++) cout << a[j][i] << " ";cout << endl;}// 显示转置数据cout << "Transpose of a:" << endl;for (i=0;i<NC;i++) {for (j=0;j<NR;j++) cout << a[j][i] << " ";cout << endl;}return 0;}===执行例子：input row col3 2input 3*2 data1 2 3 4 5 6Original matrix a:1 23 45 6Transpose of a:1 3 52 4 6