1. 程式人生 > >memset()函式及其作用

memset()函式及其作用

1. memset()函式原型是extern void *memset(void *buffer, int c, int count)        buffer:為指標或是陣列,

              c:是賦給buffer的值,

       count:是buffer的長度.


       這個函式在socket中多用於清空陣列.如:原型是memset(buffer, 0, sizeof(buffer))

       Memset用來對一段記憶體空間全部設定為某個字元,一般用在對定義的字串進行初始化為‘ ’或‘/0’;

      例:char a[100];memset(a, '/0', sizeof(a));

    memset可以方便的清空一個結構型別的變數或陣列。

如:

struct sample_struct
{
char csName[16];
int iSeq;
int iType;
};

對於變數:
struct sample_strcut stTest;

一般情況下,清空stTest的方法:

stTest.csName[0]='/0';
stTest.iSeq=0;
stTest.iType=0;

用memset就非常方便:
memset(&stTest,0,sizeof(struct sample_struct));

如果是陣列:

struct sample_struct TEST[10];

memset(TEST,0,sizeof(struct sample_struct)*10);

2.提問:“將s所指向的某一塊記憶體中的每個位元組的內容全部設定為ch指定的ASCII值,塊的大小由第三個引數指定,這個函式通常為新申請的記憶體做初始化工作。用 法: void *memset(void *s, char ch, unsigned n);”


//“將s所指向的某一塊記憶體中的每個位元組的內容全部設定為ch指定的ASCII值”幹什麼?為什麼說“這個函式通常為新申請的記憶體做初始化工作。”?

答:剛分配的記憶體空間,或者是被你用過的記憶體空間裡面的資料是不固定的為了避免這些無用的資料給自己的程式帶來影響,可以用memset把這些記憶體裡面的資料置成某個數值一般情況下是置0,當然,如果你的程式不會受這些無用資料影響,就不用做這個工作了所謂“初始化”,當然是指將你定義的變數或申請的空間賦予你所期望的值,例如語句int i=0;就表明定義了一個變數i,並初始化為0;如果int j=5;就表明定義了一個變數j,並初始化為5。

       但是對於大塊兒記憶體的分配,這種方法當然不行,例如int arr[100];定義了陣列arr,包含100個元素,如果你寫成int arr[100]=0;想將陣列全部內容初始化為0,是不行的,連編譯都不能通過。這種情況的初始化,有兩種方法,一種是一個一個的初始化,如for(int i=0;i<100;i++)arr[i]=0;就完成了陣列的初始化。另一種方法,就是使用memset:一個語句就夠了--memset(arr,0,sizeof(int)*100);
各引數解釋如下:arr是陣列的首地址,0就是要講這些地址的內容賦值為0,sizeof(int)求出int型別的長度,乘以100就表示arr陣列的整個長度。


         當然,如果用malloc分配的記憶體,一般只能使用memset來初始化了,用第一種初始化方法明顯不合適。

         例:char ch[10]
         比如memset(ch,0,8),就是把陣列ch前八項置為零,後面的不一定為零。比如剛開始ch[1]='z',ch[8]='a',ch[9]='b',經過memset後,ch[1]為零了,而ch[8],ch[9]都不變.

3.memset函式詳細說明 
       1)void *memset(void *s,int c,size_t n)
        總的作用:將已開闢記憶體空間 s 的首 n 個位元組的值設為值 c。

       2).memset() 函式常用於記憶體空間初始化。如:
           char str[100];
           memset(str,0,100);


       3).memset可以方便的清空一個結構型別的變數或陣列。

           如:
           struct sample_struct{
                      char csName[16];
                       int iSeq;
                       int iType;
           };

           對於變數:
           struct sample_strcut stTest;

           一般情況下,清空stTest的方法:
           stTest.csName[0]='/0';
           stTest.iSeq=0;
           stTest.iType=0;

           用memset就非常方便:
           memset(&stTest,0,sizeof(struct sample_struct));

           如果是陣列:
           struct sample_struct TEST[10];
           則
           memset(TEST,0,sizeof(struct sample_struct)*10);

           #include <mem.h>
           void* memset(void* s, int c, size_t n){
                     unsigned char* p = (unsigned char*) s;

                     while (n > 0) {
                                *p++ = (unsigned char) c;
                                  --n;
                      }

                     return s;
           }

 
        memset()的函式, 它可以一位元組一位元組地把整個陣列設定為一個指定的值。 memset()函式在mem.h標頭檔案中宣告,它把陣列的起始地址作為其第一個引數,第二個引數是設定陣列每個位元組的值,第三個引數是陣列的長度(位元組數,不是元素個數)。其函式原型為:
    void *memset(void*,int,unsigned);
  其中void*表示地址。
  例如,下面的程式碼用陣列做引數傳遞給標準函式memset(),以讓其將陣列設定成全0:
    #include<mem.h>
    void main()
    {
     int ia1[50];
     int ia2[500];
     memset(iai,0,50*sizeof(int));
     memset(ia2,0,500*sizeof(int));
     //
    }
  memset()的第一個實參是陣列名,陣列名作引數即陣列作引數,它僅僅只是一個數組的起始地址而已。
  在函式memset()棧區,從返回地址往上依次為第1,2,3個引數。第1個引數中的內容是main()函式中定義的陣列ia1的起始地址。第2個引數是給陣列設定的值(0),第3個引數是陣列的長度(50*2)。函式返回時,main()函式的陣列中內容全置為0。

0 && image.height>0){if(image.width>=700){this.width=700;this.height=image.height*700/image.width;}}">


memset函式詳細說明

1。void *memset(void *s,int c,size_t n)
總的作用:將已開闢記憶體空間 s 的首 n 個位元組的值設為值 c。

2。例子
#include

void main(){
char *s="Golden Global View";

clrscr();

memset(s,'G',6);
printf("%s",s);

getchar();
return 0;
} 
3。memset() 函式常用於記憶體空間初始化。如:
char str[100];
memset(str,0,100);

4。memset()的深刻內涵:用來對一段記憶體空間全部設定為某個字元,一般用在對定義的字串進行初始化為‘ ’或‘/0’;例:char a[100];memset(a, '/0', sizeof(a));

memcpy用來做記憶體拷貝,你可以拿它拷貝任何資料型別的物件,可以指定拷貝的資料長度;例:char a[100],b[50]; memcpy(b, a, sizeof(b));注意如用sizeof(a),會造成b的記憶體地址溢位。

strcpy就只能拷貝字串了,它遇到'/0'就結束拷貝;例:char a[100],b[50];strcpy(a,b);如用strcpy(b,a),要注意a中的字串長度(第一個‘/0’之前)是否超過50位,如超過,則會造成b的記憶體地址溢位。

5.補充:
memset可以方便的清空一個結構型別的變數或陣列。

如:
struct sample_struct
{
char csName[16];
int iSeq;
int iType;
};

對於變數
struct sample_strcut stTest;

一般情況下,清空stTest的方法:
stTest.csName[0]='/0';
stTest.iSeq=0;
stTest.iType=0;

用memset就非常方便:
memset(&stTest,0,sizeof(struct sample_struct));

如果是陣列:
struct sample_struct TEST[10];

memset(TEST,0,sizeof(struct sample_struct)*10);

6。strcpy
原型:extern char *strcpy(char *dest,char *src);
用法:#i nclude
功能:把src所指由NULL結束的字串複製到dest所指的陣列中。
說明:src和dest所指記憶體區域不可以重疊且dest必須有足夠的空間來容納src的字串。
返回指向dest的指標。
memcpy
原型:extern void *memcpy(void *dest, void *src, unsigned int count);
用法:#i nclude
功能:由src所指記憶體區域複製count個位元組到dest所指記憶體區域。
說明:src和dest所指記憶體區域不能重疊,函式返回指向dest的指標。
memset
原型:extern void *memset(void *buffer, int c, int count);
用法:#i nclude
功能:把buffer所指記憶體區域的前count個位元組設定成字元c。
說明:返回指向buffer的指標。

memcpy用來做記憶體拷貝,你可以拿它拷貝任何資料型別的物件,可以指定拷貝的資料長度。

例:char a[100],b[50]; memcpy(b, a, sizeof(b));注意如用sizeof(a),會造成b的記憶體地址溢位。

Strcpy  就只能拷貝字串了,它遇到'/0'就結束拷貝。

例:char a[100],b[50];strcpy(a,b);如用strcpy(b,a),要注意a中的字串長度(第一個‘/0’之前)是否超過50位,如超過,則會造成b的記憶體地址溢位。

str也可以用用個引數的strncpy(a,b,n)

========================================================

memset主要應用是初始化某個記憶體空間。
memcpy是用於copy源空間的資料到目的空間中。
strcpy用於字串copy,遇到‘/0’,將結束。

如果你理解了這些,你應該知道他們的區別:例如你初始化某塊空間的時候,用到memcpy,那麼應該怎麼寫,是不是顯得很笨。
int m[100]
memset((void*)m,0x00,sizeof(int)*100);//Ok!
memcpy((void*)m,"/0/0/0/0....",sizeof(int)*100);//it’s wrong.

memset用法詳解(轉)

memest原型 (please type "man memset" in your shell)

void *memset(void *s,   int c, size_t n);

memset:作用是在一段記憶體塊中填充某個給定的值,它對較大的結構體或陣列進行清零操作的一種最快方法。

常見的三種錯誤

第一: 搞反了c 和 n的位置.

一定要記住 如果要把一個char a[20]清零, 一定是 memset(a, 0, 20) 
而不是 memset(a, 20,   0)

第二: 過度使用memset, 我想這些程式設計師可能有某種心理陰影, 他們懼怕未經初始化的記憶體, 所以他們會寫出這樣的程式碼:

char buffer[20];

memset(buffer, 0, sizeof((char)*20)); 
strcpy(buffer, "123");

這裡的memset是多餘的. 因為這塊記憶體馬上就被覆蓋了, 清零沒有意義.

第三: 其實這個錯誤嚴格來講不能算用錯memset, 但是它經常在使用memset的場合出現

int some_func(struct something *a){ 
… 
… 
memset(a, 0, sizeof(a)); 
… 
}

:為何要用memset置零?memset( &Address, 0, sizeof(Address));經常看到這樣的用法,其實不用的話,分配資料的時候,剩餘的空間也會置零的。

答:1.如果不清空,可能會在測試當中出現野值。 你做下面的試驗看看結果()

char buf[5];

CString str,str1; //memset(buf,0,sizeof(buf)); for(int i = 0;i<5;i++) { str.Format(“%d “,buf[i]); str1 +=str ; } TRACE(“%s/r/n“,str1)

2.其實不然!特別是對於字元指標型別的,剩餘的部分通常是不會為0的,不妨作一個試驗,定義一個字元陣列,並輸入一串字元,如果不用memset實現清零,使用MessageBox顯示出來就會有亂碼(0表示NULL,如果有,就預設字元結束,不會輸出後面的亂碼)

問:

如下demo是可以的,能把陣列中的元素值都設定成字元1
#include <iostream>
#include <cstring>
using namespace std;
int main()
{
     char a[5];
     memset(a,'1',5);
     for(int i = 0;i < 5;i++)
       cout<<a[i]<<"   ";
     system("pause");
     return 0;
}
而,如下程式想吧陣列中的元素值設定成1,卻是不可行的
#include <iostream>
#include <cstring>
using namespace std;
int main()
{
     int a[5];
     memset(a,1,5);//這裡改成memset(a,1,5 *sizeof(int))也是不可以的
     for(int i = 0;i < 5;i++)
       cout<<a[i]<<"   ";
     system("pause");
     return 0;
}
問題是:

1,第一個程式為什麼可以,而第二個不行,
2,不想要用for,或是while迴圈來初始化int a[5];能做到嗎?(有沒有一個像memset()這樣的函式初始化)

答:

1.因為第一個程式的陣列a是字元型的,字元型佔據記憶體大小是1Byte,而memset函式也是以位元組為單位進行賦值的,所以你輸出沒有問題。而第二個程式a是整型的,使用memset還是按位元組賦值,這樣賦值完以後,每個陣列元素的值實際上是0x01010101即十進位制的16843009。你看看你輸出結果是否這樣?

2.如果用memset(a,1,20);
就是對a指向的記憶體的20個位元組進行賦值,每個都用ASCII為1的字元去填充,轉為二進位制後,1就是00000001,佔一個位元組。一個INT元素是4位元組,合一起就是1000000010000000100000001,就等於16843009,就完成了對一個INT元素的賦值了。