Hur Memset-funktionen används

I C används funktionen memset () för att ställa in ett bytevärde till ett minnesblock byte för byte. Denna funktion är användbar för initialisering av ett minnesblock byte för byte med ett visst värde. I den här artikeln kommer vi att se i detalj hur denna funktion kan användas. Så, låt oss komma igång.

Rubrikfil:

sträng.h

Syntax:

1	void * memset (void * str, int ch, size_t n)

Den här funktionen ställer in den första n byte i minnesblocket pekade av str förbi ch.

Argument:

Funktionen tar 3 argument:

str: Detta är pekaren på minnesplatsen där minnet ska ställas in. Detta är en ogiltig pekare, så vi kan ställa in vilken typ av minne som helst, men minnet ställs in byte för byte.
ch: Detta är det värde som ska kopieras till minnesblocket. Detta är ett heltal, men det konverteras till ett osignerat tecken innan det kopieras.
n: Detta är antalet byte i minnesblocket som ställts in.

Returvärden:

memset () returnerar den första adressen till minnesblocket varifrån den börjar ställa in värdet.

Exempel:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

// Exempel1.c
#omfatta
#omfatta
int main ()

char str [30] = "ABCD EFGH";
printf ("Before memset =>% s", str);
memset (str, 'x', 3);
printf ("\ nEfter memset =>% s \ n", str);
returnera 0;

I exempel 1.c, vi har förklarat en teckenuppsättning av storlek 30. Sedan har vi initierat den med strängen “ABCD EFGH.”I memset-funktionen har vi skickat 3 argument str, 'x' och 3. Så, minnesblocket som pekas av str återställs de första 3 tecknen med 'x.'Efter memset, när vi skriver ut minnet, får vi "xxxD EFGH.”

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

// Exempel2.c
#omfatta
#omfatta
int main ()

char str [30] = "ABCD EFGH";
printf ("Before memset =>% s", str);
memset (str + 4, 'x', 3);
printf ("\ nEfter memset =>% s \ n", str);
returnera 0;

I exempel 2.c, vi har skickat str + 4 till memset-funktionen. Så det återställer minnet efter den fjärde platsen för str. Efter memset, när vi skriver ut minnet, får vi “ABCDxxxGH.”

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

// Exempel3.c
#omfatta
#omfatta
int main ()

int arr [5], i;
memset (arr, 10,5 * sizeof (arr [0]));
printf ("\ narr Elements => \ n");
för (i = 0; i<5;i++)
printf ("% d \ t", arr [i]);
printf ("\ n");
returnera 0;

I exempel 3.c, vi har förklarat en heltalsserie av storlek 5 och försöker initialisera den med 10. Men från utdata har vi sett att matrisen inte initialiserats med 10; istället har vi värdet “168430090”. Detta beror på att heltalets värde är större än en byte och memset-funktionen omvandlar värdet till ett osignerat tecken innan det kopieras. Nu får vi se hur vi får värdet “168430090”.

Den binära representationen av 10 är 00000000 00000000 00000000 00001010.

När heltal omvandlas till osignerad röd, beaktas den lägre 1 byten. Så när 10 konverteras till osignerad röd, är det en binär representation är 00001010.

memset () -funktionen ställer in minnesplats byte för byte. Så totalt kommer 4 byte att vara: 00001010 00001010 00001010 00001010.

Decimalvärdet för den binära representationen av 4 byte är 168430090.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

// Exempel4.c
#omfatta
#omfatta
int main ()

int arr [5], i;
memset (arr, 0,5 * sizeof (arr [0]));
printf ("\ narr Elements => \ n");
för (i = 0; i<5;i++)
printf ("% d \ t", arr [i]);
printf ("\ n");
returnera 0;

I exempel 4.c, vi har initierat heltalet med 0. Alla bitar i den binära representationen av 0 är 0. Så matrisen initialiseras med 0.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

// Exempel 5.c
#omfatta
#omfatta
int main ()

int arr [5], i;
memset (arr, -1,5 * sizeof (arr [0]));
printf ("\ narr Elements => \ n");
för (i = 0; i<5;i++)
printf ("% d \ t", arr [i]);
printf ("\ n");
returnera 0;

I exempel 5.c, vi har initierat heltalet med 0. Alla bitar i den binära representationen av -1 är 1. Så matrisen initialiseras med -1.

Slutsats:

I den här artikeln har vi sett med hjälp av memset-funktionen hur vi kan initiera eller ställa in värdet på ett minnesblock effektivt. Vi kan ställa in vilket tecken som helst och 0 eller -1 som ett heltal till ett minnesblock. Memset-funktionen är snabbare för att ställa in en stor bit av angränsande minne jämfört med att helt enkelt ställa in platsen med en slinga.