memcpy

有的。Arrays类的静态方法public static char[] copyOf(char[] original,int newLength)复制指定的数组，截取或用 null 字符填充（如有必要），以使副本具有指定的长度。对于在原数组和副本中都有效的所有索引，这两个数组将包含相同的值。对于在副本中有效而在原数组无效的所有索引，副本将包含 "\u000"。当且仅当指定长度大于原数组的长度时，这些索引存在。Arrays的copyOf()有多个重载方法，基本的数组复制和拷贝都有的。具体看API ：java.util.Arrays

memcpy不区分大端小端的，memcpy只是将源地址之后的n个字节拷贝到目的地址中。

原型：extern void *memccpy(void *dest, void *src, unsigned char c, unsigned int count);　　参数：　　dest Pointer to the destination.　　src Pointer to the source.　　c Last character to copy.　　count Number of characters.　　用法：#include <string.h>　　功能：由src所指内存区域复制不多于count个字节到dest所指内存区域，如果遇到字符c则停止复制。　　返回值：如果c没有被复制，则返回NULL，否则，返回一个指向紧接着dest区域后的字符的指针。 这个函数一般不怎么常用。

编译的时候不会报错的，运行的时候就可能会出现异常了。

memcpy的参数是 Src_addr , size 如果内存不连续，多次采用memcpy，指定多段内存的地址和size

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

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

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];目前的代码 只是分配了一个字符空间, 初始化为括号里面的值.

请教，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) {

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

你需要声明 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; }

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

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

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

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

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

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

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

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

#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); // 成功了}

实际上第一个办法比第二个办法更快memcpy的方式跟你第一个是一样的，但是多了函数调用的开销，所有第一个更快实际上当你开启release模式后，第一个和第二个的调用速度是一样的建议使用memcpy，第一个办法会降低可读性

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

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

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

不好意思看错了。

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

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

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

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

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

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

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

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

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

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的字符长度+""。

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

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

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;}

语法: #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 重叠，则函数行为不确定。

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

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

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

区别：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不保证拷贝的结果的正确。

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

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

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

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