Hvordan Memset-funksjonen brukes

I C brukes funksjonen memset () til å sette en byteverdi til en minneblokkbyte for byte. Denne funksjonen er nyttig for initialisering av en minneblokk byte for byte med en bestemt verdi. I denne artikkelen vil vi se i detalj hvordan denne funksjonen kan brukes. Så la oss komme i gang.

Overskriftsfil:

streng.h

Syntaks:

1	ugyldig * memset (ugyldig * str, int ch, størrelse_t n)

Denne funksjonen angir den første n byte i minneblokken pekt av str av ch.

Argumenter:

Funksjonen tar 3 argumenter:

str: Dette er pekeren på minneplasseringen der minnet blir satt. Dette er en tom peker, så vi kan angi hvilken som helst type minneblokk, men minnet vil bli satt byte for byte.
ch: Dette er verdien som skal kopieres til minneblokken. Dette er et heltall, men det konverteres til et usignert tegn før det kopieres.
n: Dette er antall byte i minneblokken som er angitt.

Returverdier:

memset () returnerer den første adressen til minneblokken der den begynner å sette verdien.

Eksempler:

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

// Eksempel1.c
#inkludere
#inkludere
int main ()

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

I eksempel 1.c, vi har erklært ett tegnoppsett av størrelse 30. Så har vi initialisert den med strengen “ABCD EFGH.”I memset-funksjonen har vi passert 3 argumenter str, 'x' og 3. Så, minneblokken som pekes av str, tilbakestilles de første 3 tegnene med 'x.Etter memset, når vi skriver ut minnet, får vi “xxxD EFGH.”

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

// Eksempel2.c
#inkludere
#inkludere
int main ()

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

I eksempel 2.c, vi har sendt str + 4 til memset-funksjonen. Så, det tilbakestiller minnet etter den fjerde plasseringen av str. Etter memset, når vi skriver ut minnet, får vi “ABCDxxxGH.”

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

// Eksempel3.c
#inkludere
#inkludere
int main ()

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

I eksempel 3.c, vi har erklært et heltall matrise av størrelse 5 og prøver å initialisere det med 10. Men fra utdata har vi sett at matrisen ikke er initialisert med 10; i stedet har vi verdien “168430090”. Dette er fordi heltallverdien er større enn en byte, og memset-funksjonen konverterer verdien til et usignert tegn før det kopieres. Nå skal vi se hvordan vi får verdien “168430090”.

Den binære representasjonen av 10 er 00000000 00000000 00000000 00001010.

Når heltall konverteres til usignert røye, blir den nedre 1 byte vurdert. Så når 10 konverteres til usignert røye, er det en binær representasjon er 00001010.

memset () -funksjonen angir minneplassering byte for byte. Totalt 4 byte blir altså: 00001010 00001010 00001010 00001010.

Desimalverdien for den binære representasjonen av 4 byte er 168430090.

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

// Eksempel4.c
#inkludere
#inkludere
int main ()

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

I eksempel 4.c, vi har initialisert heltallmatrisen med 0. Alle biter av den binære representasjonen av 0 er 0. Så matrisen initialiseres med 0.

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

// Eksempel5.c
#inkludere
#inkludere
int main ()

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

I eksempel 5.c, vi har initialisert heltallmatrisen med 0. Alle biter av den binære representasjonen av -1 er 1. Så matrisen initialiseres med -1.

Konklusjon:

I denne artikkelen har vi sett ved hjelp av memset-funksjonen hvordan vi kan initialisere eller sette verdien til en minneblokk effektivt. Vi kan sette et hvilket som helst tegn og 0 eller -1 som et heltall til en minneblokk. Memset-funksjonen er raskere for å angi et stort stykke sammenhengende minne sammenlignet med å bare sette plasseringen ved hjelp av en sløyfe.