Kuidas Memseti funktsiooni kasutatakse

C-s kasutatakse funktsiooni memset () ühebaidise väärtuse määramiseks mäluploki baidile baidi kaupa. See funktsioon on kasulik mäluploki baidi initsialiseerimiseks baidi järgi konkreetse väärtuse järgi. Selles artiklis näeme üksikasjalikult, kuidas seda funktsiooni saab kasutada. Alustame siis.

Päisefail:

string.h

Süntaks:

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

See funktsioon määrab esimese n tähistatud mäluploki baidid str kõrval ch.

Argumendid:

Funktsioonil on 3 argumenti:

str: See on mälukoha osuti, kuhu mälu seatakse. See on tühine osuti, nii et saame määrata mis tahes tüüpi mäluploki, kuid mälu määratakse baidi kaupa.
ch: See on väärtus, mis tuleb kopeerida mäluplokki. See on täisarv, kuid see teisendatakse enne kopeerimist märkimata märgiks.
n: See on määratud baitide arv mäluplokis.

Tagastusväärtused:

mälukaart () tagastab mäluploki esimese aadressi, kust ta väärtust hakkab määrama.

Näited:

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

// Näide1.c
# kaasata
# kaasata
int main ()

char str [30] = "ABCD EFGH";
printf ("Enne mälukomplekti =>% s", str);
memset (str, 'x', 3);
printf ("\ nPärast mälukaarti =>% s \ n", str);
tagastama 0;

Näites1.c, oleme deklareerinud ühe tähemassiivi suurusega 30. Seejärel oleme selle initsialiseerinud stringiga „ABCD EFGH.”Memset-funktsioonis oleme edastanud 3 argumenti str, 'x' ja 3. Niisiis, str -iga tähistatud mäluplokk lähtestab esimesed 3 märki tähega 'x.'Pärast mälu ühendamist saame mälu printides "xxxD EFGH.”

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

// Näide2.c
# kaasata
# kaasata
int main ()

char str [30] = "ABCD EFGH";
printf ("Enne mälukomplekti =>% s", str);
mälukaart (str + 4, 'x', 3);
printf ("\ nPärast mälukaarti =>% s \ n", str);
tagastama 0;

Näites2.c, me oleme funktsiooni stressi + 4 edastanud. Nii lähtestas see mälu pärast str. 4. asukohta. Pärast mälu ühendamist saame mälu printides sõnumi „ABCDxxxGH.”

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

Näide3.c
# kaasata
# kaasata
int main ()

int arr [5], i;
mälukaart (arr, 10,5 * sizeof (arr [0]));
printf ("\ narr Elements => \ n");
jaoks (i = 0; i<5;i++)
printf ("% d \ t", arr [i]);
printf ("\ n");
tagastama 0;

Näites3.c, oleme deklareerinud täisarvulise massiivi suurusega 5 ja proovime seda initsialiseerida 10-ga. Kuid väljundist oleme näinud, et massiivi ei initsialiseerita 10-ga; selle asemel oleme saanud väärtuse “168430090”. Seda seetõttu, et täisarv on suurem kui üks bait ja funktsioon memset teisendab väärtuse enne kopeerimist märkimata märgiks. Nüüd näeme, kuidas saame väärtuse „168430090”.

10 binaarne esitus on 00000000 00000000 00000000 00001010.

Kui täisarv teisendatakse allkirjastamata sümboliks, võetakse arvesse madalamat 1 baiti. Niisiis, kui 10 teisendatakse allkirjastamata täheks, on see binaarne esitus 00001010.

funktsioon memset () määrab mälu asukoha baidi kaupa. Kokku on 4 baiti: 00001010 00001010 00001010 00001010.

4-baidise binaarse kujutise kümnendväärtus on 168430090.

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

// Näide4.c
# kaasata
# kaasata
int main ()

int arr [5], i;
mälukaart (arr, 0,5 * sizeof (arr [0]));
printf ("\ narr Elements => \ n");
jaoks (i = 0; i<5;i++)
printf ("% d \ t", arr [i]);
printf ("\ n");
tagastama 0;

Näites4.c, oleme initsialiseerinud täisarvu massiivi 0-ga. 0 binaarse esituse kõik bitid on 0. Nii et massiiv initsialiseeritakse 0-ga.

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

Näide5.c
# kaasata
# kaasata
int main ()

int arr [5], i;
mälukaart (arr, -1,5 * sizeof (arr [0]));
printf ("\ narr Elements => \ n");
jaoks (i = 0; i<5;i++)
printf ("% d \ t", arr [i]);
printf ("\ n");
tagastama 0;

Näites5.c, oleme initsialiseerinud täisarvu massiivi 0-ga. Kõik binaarse esituse -1 bitid on 1. Nii et massiivi lähtestab -1.

Järeldus:

Selles artiklis oleme memset-funktsiooni kasutamisel näinud, kuidas saame mäluploki väärtust tõhusalt lähtestada või seadistada. Me võime mäluplokile määrata täisarvuna mis tahes märgi ja 0 või -1. Memset-funktsioon on suurema külgneva mälu suuruse määramine kiirem, kui lihtsalt asukoha määramine silmusega.