一、memmove
介紹：memmove用于從src拷貝count個位元組到dest，如果目标區域和源區域有重疊的話，memmove能夠保證源串在被覆寫之前将重疊區域的位元組拷貝到目标區域中。但複制後src内容會被更改。但是當目标區域與源區域沒有重疊則和memcpy函數功能相同。
原型：void *memmove( void* dest, const void* src, size_t count ); 頭檔案：<string.h> 功能：由src所指記憶體區域複制count個位元組到dest所指記憶體區域。
1 // memmove.c
2 #include <stdio.h>
3 #include <string.h>
4 int main(void)
5 {
6 char s[]="Golden Global View";
7 memmove(s,s+7,strlen(s)+1-7);
8 printf("%s",s);
9 getchar();
10 return 0;
11 }
12 //程式輸出結果：Global View
13 //MSDN上也有相關示例。
14 //注意：這裡的拷貝長度strlen(s)+1-7表示把字元串結尾的'\0'也拷貝進來。 memmove() 與 memcpy() 類似都是用來複制 src 所指的記憶體内容前 num 個位元組到 dest 所指的位址上。不同的是，memmove() 更為靈活，當src 和 dest 所指的記憶體區域重疊時，memmove() 仍然可以正确的處理，不過執行效率上會比使用 memcpy() 略慢些。
二、memset
memset是計算機中C++語言函數。将s所指向的某一塊記憶體中的前n個位元組的内容全部設定為ch指定的ASCII值， 塊的大小由第三個參數指定，這個函數通常為新申請的記憶體做初始化工作， 其傳回值為指向s的指針。
函數介紹：
void *memset(void *s, int ch, size_t n);
函數解釋：将s中前n個位元組 （typedef unsigned int size_t ）用 ch 替換并傳回 s 。
memset：作用是在一段記憶體塊中填充某個給定的值，它是對較大的結構體或數組進行清零操作的一種最快方法。
常見錯誤
第一： 搞反了 ch 和 n 的位置.
一定要記住如果要把一個char a[20]清零，一定是 memset(a,0,20);
而不是 memset(a,20,0);
第二： 過度使用memset，我想這些程式員可能有某種心理陰影，他們懼怕未經初始化的記憶體，是以他們會寫出這樣的代碼：
charbuffer[4];
memset(buffer,0,sizeof(char)*4);
strcpy(buffer,"123");
//"123"中最後隐藏的'\0'占一位，總長4位。
這裡的memset是多餘的. 因為這塊記憶體馬上就被全部覆寫，清零沒有意義.
另：以下情況并不多餘，因某些編譯器配置設定空間時，記憶體中預設值并不為0：
charbuffer[20];
memset(buffer,0,sizeof(char)*20);
memcpy(buffer,"123",3);
//這一條的memset并不多餘，memcpy并沒把buffer全部覆寫，如果沒有memset，
//用printf列印buffer會有亂碼甚至會出現段錯誤。
//如果此處是strcpy(buffer,"123");便不用memset,strcpy雖然不會覆寫buffer但是會拷貝字元串結束符
第三： 其實這個錯誤嚴格來講不能算用錯memset，但是它經常在使用memset的場合出現
intsome_func(structsomething*a)
{
…
…
memset(a,0,sizeof(a));
…
}
這裡錯誤的原因是VC函數傳參過程中的指針降級，導緻sizeof(a)，傳回的是一個 something*指針類型大小的的位元組數，如果是32位，就是4位元組。
3常見問題
問：為何要用memset置零?memset(&Address,0,sizeof(Address））；經常看到這樣的用法，其實不用的話，配置設定資料的時候，剩餘的空間也會置零的。
答：1.如果不清空，可能會在測試當中出現野值。你做下面的試驗看看結果()
#include<iostream>
#include"string.h"
#include<afx.h>
usingnamespacestd;
intmain(){
charbuf[5];
CStringstr;
CStringstr1;
CStringstr2;
memset(buf,0,sizeof(buf));
for(inti=0;i<5;i++){
str.Format("%d",buf[i]);
str1+=str;
}
str2.Format("%d",str1);
cout<<str2<<endl;
system("pause");
return0;
}
這樣寫，有沒有memset，輸出都是一樣
⒉其實不然！特别是對于字元指針類型的，剩餘的部分通常是不會為0的，不妨作一個試驗，定義一個字元數組，并輸入一串字元，如果不用memset實作清零，使用MessageBox顯示出來就會有亂碼（0表示NULL，如果有，就預設字元結束，不會輸出後面的亂碼）
問：
如下demo是可以的，能把數組中的元素值都設定成字元1，
#include<iostream>
#include<cstring>
usingnamespacestd;
intmain(){
chara[5];
memset(a,'1',5）;
for(inti=0;i<5;i++)
cout<<a[i]<<"";
system("pause");
return0;
}
而，如下程式想把數組中的元素值設定成1，卻是不可行的
#include<iostream>
#include<cstring>
#include<windows.h>
usingnamespacestd;
intmain()
{
inta[5];
memset(a,1,20）;//如果這裡改成memset(a,1,5*sizeof(int))也可以，因為memset按位元組指派。
for(inti=0;i<5;i++)
cout<<a[i]<<"";
system("pause");
return0;
}
問題是：
1，第一個程式為什麼可以，而第二個不行？
因為第一個程式的數組a是字元型的，字元型占據記憶體大小是1Byte，而memset函數也是以位元組為機關進行指派的，是以你輸出沒有問題。而第二個程式a是整型的，使用 memset還是按位元組指派，這樣指派完以後，每個數組元素的值實際上是0x01010101即十進制的16843009。
2，不想要用for，或是while循環來初始化int a[5]；能做到嗎？（有沒有一個像memset()這樣的函數初始化）
如果用memset(a,1,20);（實際上與memset(a,1,5*sizeof(int))結果是一樣的）就是對a指向的記憶體的20個位元組進行指派，每個都用ASCⅡ為1的字元去填充，轉為二進制後，1就是00000001，占一個位元組。一個INT元素是4位元組，合一起是0000 0001,0000 0001,0000 0001,0000 0001，轉化成十六進制就是0x01010101，就等于16843009，就完成了對一個INT元素的指派了。
4程式範例
編輯
#include<string.h>
#include<stdio.h>
#include<memory.h>
intmain(void)
{
charbuffer[]="Helloworld\n";
printf("Bufferbeforememset:%s\n",buffer);
memset(buffer,'*',strlen(buffer));
printf("Bufferaftermemset:%s\n",buffer);
return0;
}
輸出結果：
Bufferbeforememset:Helloworld
Bufferaftermemset:***********
編譯平台：
Microsoft Visual C++6.0
也不一定就是把内容全部設定為ch指定的ASCⅡ值，而且該處的ch可為int或者其他類型，并不一定要是char類型。例如下面這樣：
intarray[5]={1,4,3,5,2};
for(inti=0;i<5;i++)
cout<<array[i]<<"";
cout<<endl;
memset(array,0,5*sizeof(int));
for(intk=0;k<5;k++)
cout<<array[k]<<"";
cout<<endl;
輸出的結果就是：
14352
00000
後面的表大小的參數是以位元組為機關，是以，對于int或其他的就并不是都乘預設的1（字元型）了。而且不同的機器上int的大小也可能不同，是以最好用sizeof()。
要注意的是，memset是對位元組進行操作，
是以上述程式如果改為
intarray[5]={1,4,3,5,2};
for(inti=0;i<5;i++)
cout<<array[i]<<"";
cout<<endl;
memset(array,1,5*sizeof(int));//注意這裡與上面的程式不同
for(intk=0;k<5;k++)
cout<<array[k]<<"";
cout<<endl;
輸出的結果就是：
14352
1684300916843009168430091684300916843009
為什麼呢？
因為memset是以位元組為機關就是對array指向的記憶體的4個位元組進行指派，每個都用ASCⅡ為1的字元去填充，轉為二進制後，1就是00000001，占一個位元組。一個INT元素是4位元組，合一起就是
00000001000000010000000100000001
就等于16843009，就完成了對一個INT元素的指派了。
是以用memset對非字元型數組賦初值是不可取的！
例如有一個結構體Some x，可以這樣清零：
memset(&x,0,sizeof(Some));
如果是一個結構體的數組Some x[10]，可以這樣：
memset(x,0,sizeof(Some)*10）；
memset函數詳細說明
1。void *memset(void *s,int c,size_tn)
總的作用：将已開辟記憶體空間 s 的首 n 個位元組的值設為值 c。
2。例子
intmain()
{
char*s="GoldenGlobalView";
clrscr();
memset(s,'G',6);//貌似這裡有點問題//這裡沒有問題，可以編譯運作，樓主在這裡将右括号和分号變成了中文輸入法
//單步運作到這裡會提示記憶體通路沖突
//肯定會通路沖突，s指向的是不可寫空間。
printf("%s",s);
getchar();
return0;
}
【以上例子出現記憶體通路沖突應該是因為s被當做常量放入程式存儲空間，如果修改為 char s[]="Golden Global View";則沒有問題了。】
【應該是沒有問題的，字元串指針一樣可以，并不是隻讀記憶體，可以正常運作】
【此執行個體可以正常編譯運作，并不像樓主說的需要char s[]】
【memset(s,'G',6)這樣是存在記憶體通路沖突的，因為s為常量字元串，不能修改的】
3。memset() 函數常用于記憶體空間初始化。如：
charstr[100];
memset(str,0,100）；
4。memset()的深刻内涵：用來對一段記憶體空間全部設定為某個字元，一般用在對定義的字元串進行初始化為‘memset(a,'\0',sizeof(a));
5。補充：一點技巧
memset可以友善的清空一個結構類型的變量或數組。
如：
structsample_struct
{
charcsName[16];
intiSeq;
intiType;
};
對于變量
structsample_structstTest;
一般情況下，清空stTest的方法：
stTest.csName[0]={'\0'};
stTest.iSeq=0;
stTest.iType=0;
用memset就非常友善：
memset(&stTest,0,sizeof(structsample_struct));
如果是數組：
structsample_structTEST[10];
則
memset(TEST,0,sizeof(structsample_struct)*10）；
另外：
如果結構體中有數組的話還是需要對數組單獨進行初始化處理的。 三、zeromemory 四、memcpy
memcpy：
c和c++使用的記憶體拷貝函數，memcpy函數的功能是從源src所指的記憶體位址的起始位置開始拷貝n個位元組到目标dest所指的記憶體位址的起始位置中。
函數原型：
void *memcpy(void *dest, const void *src, size_t n);
所需頭檔案：
C語言中使用#include <string.h>;
C++中使用#include <cstring>和#include <string.h>都可以。
傳回值：
函數傳回指向dest的指針。
說明：
1.source和destin所指的記憶體區域可能重疊，但是如果source和destin所指的記憶體區域重疊,那麼這個函數并不能夠確定source所在重疊區域在拷貝之前不被覆寫。而使用memmove可以用來處理重疊區域。函數傳回指向destin的指針.
2.如果目标數組destin本身已有資料，執行memcpy（）後，将覆寫原有資料（最多覆寫n）。如果要追加資料，則每次執行memcpy後，要将目标數組位址增加到你要追加資料的位址。
注意：source和destin都不一定是數組，任意的可讀寫的空間均可。
函數實作：
微軟中
void* __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中
void* memcpy(void*destaddr,voidconst*srcaddr,size_tlen)
{
char* dest=destaddr;
char const* src=srcaddr;
while(len-->0)
{
*dest++ = *src++;
}
return destaddr;
}
Linux中：
void* memcpy(void*dest,constvoid*src,size_tcount)
{
assert(dest!=NULL && src!=NULL);
char* tmp=dest;
const char* s=src;
for(size_t i=0;i<count;i++)
{
tmp[i]=s[i];
}
return dest;
}
程式例example1
作用：将s中的字元串複制到字元數組d中。
//memcpy.c
#include <stdio.h>
#include <string.h>
int main()
{
char* s="GoldenGlobalView";
chard[20];
clrscr();
memcpy(d,s,(strlen(s)+1));
printf("%s",d);
getchar();
return 0;
}
輸出結果：Golden Global View
example2
作用：将s中第13個字元開始的4個連續字元複制到d中。(從0開始)
#include<string.h>
int main(
{
char* s="GoldenGlobalView";
char d[20];
memcpy(d,s+12,4);//從第13個字元(V)開始複制，連續複制4個字元(View)
d[4]='\0';//memcpy(d,s+14*sizeof(char),4*sizeof(char));也可
printf("%s",d);
getchar();
return 0;
}
輸出結果： View
example3
作用：複制後覆寫原有部分資料
#include<stdio.h>
#include<string.h>
intmain(void)
{
char src[]="******************************";
char dest[]="abcdefghijlkmnopqrstuvwxyz0123as6";
printf("destination before memcpy:%s\n",dest);
memcpy(dest,src,strlen(src));
printf("destination after memcpy:%s\n",dest);
return 0;
}
輸出結果：
destination before memcpy:abcdefghijlkmnopqrstuvwxyz0123as6
destination after memcpy: ******************************as6
差別
strcpy和memcpy主要有以下3方面的差別。
1、複制的内容不同。strcpy隻能複制字元串，而memcpy可以複制任意内容，例如字元數組、整型、結構體、類等。
2、複制的方法不同。strcpy不需要指定長度，它遇到被複制字元的串結束符"\0"才結束，是以容易溢出。memcpy則是根據其第3個參數決定複制的長度。
3、用途不同。通常在複制字元串時用strcpy，而需要複制其他類型資料時則一般用memcpy 轉載于:https://www.cnblogs.com/Yao1991/p/6793681.html
![python算法之二分查找[圖]](data:image/gif;base64,R0lGODlhAQABAIAAAP///wAAACwAAAAAAQABAAACAkQBADs=)