C++ memmove、memset、zeromemory、memcpy函數的使用

一、memmove

介紹：memmove用於從src拷貝count個字節到dest，如果目標區域和源區域有重疊的話，memmove能夠保證源串在被覆蓋之前將重疊區域的字節拷貝到目標區域中。但復制后src內容會被更改。但是當目標區域與源區域沒有重疊則和memcpy函數功能相同。

原型：void *memmove( void* dest, const void* src, size_t count );

頭文件：<string.h>

功能：由src所指內存區域復制count個字節到dest所指內存區域。

// memmove.c
#include <stdio.h>
#include <string.h>
int main(void)
{
char s[]="Golden Global View";
memmove(s,s+7,strlen(s)+1-7);
printf("%s",s);
getchar();
return 0;
}
//程序輸出結果：Global View
//MSDN上也有相關示例。
//注意：這里的拷貝長度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