Hoe de Memset-functie wordt gebruikt

In C wordt de functie memset() gebruikt om een waarde van één byte in te stellen op een geheugenblok, byte by byte. Deze functie is handig om een geheugenblok byte voor byte te initialiseren met een bepaalde waarde. In dit artikel zullen we in detail zien hoe deze functie kan worden gebruikt. Dus laten we beginnen.

Header-bestand:

draad.h

Syntaxis:

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

Deze functie stelt de eerste in nee bytes van het geheugenblok waarnaar wordt verwezen door str door ch.

Argumenten:

De functie heeft 3 argumenten:

str: Dit is de aanwijzer van de geheugenlocatie waar het geheugen zal worden ingesteld. Dit is een lege aanwijzer, dus we kunnen elk type geheugenblok instellen, maar het geheugen wordt byte voor byte ingesteld.
ch: Dit is de waarde die naar het geheugenblok moet worden gekopieerd. Dit is een geheel getal, maar het wordt geconverteerd naar een teken zonder teken voordat het wordt gekopieerd.
nee: Dit is het aantal bytes in het geheugenblok dat is ingesteld.

Retourwaarden:

memset() retourneert het eerste adres van het geheugenblok van waaruit het begint met het instellen van de waarde.

Voorbeelden:

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

//Voorbeeld 1.c
#include
#include
int hoofd()

char str[30] = "ABCD EFGH";
printf("Vóór memset => %s",str);
memset(str,'x',3);
printf("\nNa memset => %s\n",str);
retourneer 0;

In voorbeeld1.c, we hebben één tekenreeks van grootte 30 . gedeclareerd. Daarna hebben we het geïnitialiseerd met de string "ABCD EFGH".” In de memset-functie hebben we 3 argumenten str, 'x' en 3 . doorgegeven. Dus het geheugenblok dat door str wordt aangeduid, wordt de eerste 3 tekens gereset met 'x'.' Na memset, wanneer we het geheugen afdrukken, krijgen we "xxxD EFGH.”

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

//Voorbeeld2.c
#include
#include
int hoofd()

char str[30] = "ABCD EFGH";
printf("Vóór memset => %s",str);
memset(str+4,'x',3);
printf("\nNa memset => %s\n",str);
retourneer 0;

In voorbeeld2.c, we hebben str+4 doorgegeven aan de memset-functie. Dus het reset het geheugen na de 4e locatie van str. Na memset, wanneer we het geheugen afdrukken, krijgen we "ABCDxxxGH.”

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

// Voorbeeld3.c
#include
#include
int hoofd()

int arr[5],i;
memset(arr,10,5*sizeof(arr[0]));
printf("\narr Elementen => \n");
voor(i=0;i<5;i++)
printf("%d\t",arr[i]);
printf("\n");
retourneer 0;

In voorbeeld3.c, we hebben een integer-array van grootte 5 gedeclareerd en proberen deze te initialiseren met 10. Maar uit de uitvoer hebben we gezien dat de array niet is geïnitialiseerd met 10; in plaats daarvan hebben we de waarde "168430090". Dit komt omdat de integerwaarde groter is dan één byte en de memset-functie de waarde converteert naar een niet-ondertekend teken voordat het wordt gekopieerd. Nu zullen we zien hoe we de waarde "168430090" krijgen.

De binaire representatie van 10 is 00000000 00000000 00000000 00001010.

Wanneer integer wordt geconverteerd naar teken zonder teken, wordt de onderste 1 byte beschouwd by. Dus wanneer 10 wordt geconverteerd naar teken zonder teken, is het een binaire representatie is 00001010.

memset() functie stelt de geheugenlocatie byte by byte in. Dus in totaal 4 bytes zijn: 00001010 00001010 00001010 00001010.

De decimale waarde van de binaire weergave van 4 bytes is 168430090.

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

// Voorbeeld4.c
#include
#include
int hoofd()

int arr[5],i;
memset(arr,0,5*sizeof(arr[0]));
printf("\narr Elementen => \n");
voor(i=0;i<5;i++)
printf("%d\t",arr[i]);
printf("\n");
retourneer 0;

In voorbeeld4.c, we hebben de integer-array geïnitialiseerd met 0. Alle bits van de binaire representatie van 0 is 0. Dus de array wordt geïnitialiseerd door 0.

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

// Voorbeeld5.c
#include
#include
int hoofd()

int arr[5],i;
memset(arr,-1,5*sizeof(arr[0]));
printf("\narr Elementen => \n");
voor(i=0;i<5;i++)
printf("%d\t",arr[i]);
printf("\n");
retourneer 0;

In voorbeeld5.c, we hebben de integer-array geïnitialiseerd met 0. Alle bits van de binaire weergave van -1 is 1. Dus de array wordt geïnitialiseerd door -1.

Conclusie:

In dit artikel hebben we gezien hoe we met behulp van de memset-functie de waarde van een geheugenblok efficiënt kunnen initialiseren of instellen. We kunnen elk teken en 0 of -1 instellen als een geheel getal in een geheugenblok. De Memset-functie is sneller om een groot deel van aaneengesloten geheugen in te stellen in vergelijking met het eenvoudig instellen van de locatie met behulp van een lus.