Bit felt i C

Romkompleksitet er det viktigste kriteriet på C -språket. Vi studerer et språk for å utvikle hvilken som helst programvare. Hovedobservasjonen av et produkt er å administrere data i vårt minne. Bit Field hjelper oss å administrere data på C -språket. Det hjelper oss å konsumere hukommelsen mindre enn kravet. I denne artikkelen vil vi diskutere begrepet bitfelt og deres søknad.

Kjennetegn på en variabel

Bitfelt brukes til å konsumere minnet effektivt på en slik måte at vi administrerer minneområdet vårt på en jevn måte.

Det kan brukes i struktur og union også.

Hvordan implementere et lite felt i C -programmet

1 2 3 4 5 6 7 8 9 10 11

Struct Date usignert int d; usignert int m; usignert int y; ;

Forklaring

Variabelen av typen, "dato", tar 12 byte på en kompilator som er 32 biter på en 64-biters kompilator, mens "dato" tar 6 byte på en kompilator som er 16 biter.

64 biter

D1
d	m	y
22	1	2016
4 byte	4 byte	4 byte
= 12 byte

32 biter

D1
d	m	y
22	1	2016
2 byte	2 byte	2 byte
= 6 byte

Hvordan redusere størrelsen på en variabel i et program

Programmering Eksempel 1

I dette programmeringseksemplet vil vi se hvilken mengde minne som konsumeres av enhver form for variabel.

1 2 3 4 5 6 7 8 9 10 11 12 1. 3 14 15 16 17 18 19 20 21 22 23 24 25

#inkludere Struct Dato // Definere brukerdefinert datatype. usignert int d; // Datamedlem av datatype. usignert int m; usignert i t y; ; int main () struct Dato d1 = 22, 1, 2016; // datatypevariabel er erklært og initialisert. printf ("størrelse på d1 er %d", størrelse av (d1)); retur 0;

Produksjon

Forklaring

Verdiene på datoen og måneden er fast: Datoen er 31, og måneden er 12.

2	31
2	15-2
2	7-1
2	3-1
	1-1
2	12
2	6-0
2	3-0
	1-1
11111 1100	1100
(5 biter)	(4 biter)

Fra forrige beregning av datoen prøver vi å si at for å representere en maksimal dag i løpet av en måned (31), er det bare 5 biter med minne som er nødvendig av 4 byte eller 32 biter. Det er det samme også når det gjelder å telle måneder. Det er 12 måneder i løpet av et år. For å representere 12 i minnet, tar det bare 4 biter av 4 byte eller 32 biter. Dermed er det klart fra denne oppfatningen at resten av minnet er bortkastet i tilfelle dag og måned på en dato. I denne situasjonen hjelper bitfeltet oss med å løse problemet.

Programmering Eksempel 2

I dette programmeringseksemplet vil vi bruke bitfeltet til å konsumere minne for variabelen.

1 2 3 4 5 6 7 8 9 10 11 12 1. 3 14 15 16 17 18 19 20 21 22 23 24

#inkludere Struct Dato // Definere brukerdefinert datatype. usignert int d: 5; // Datamedlem av datatype. usignert int m: 4; // Bruke bitfelt som tykktarm: usignert int y; ; int main () struct Dato d1 = 22, 1, 2016; // datatypevariabel er erklært og initialisert. printf ("størrelse på d1 er %d", størrelse av (d1)); retur 0;

Produksjon:

Forklaring

Vi vet at verdien av D alltid er fra 1 til 31. Ett år inneholder 12 måneder. Så initialiseringsverdien av månedsvariabelen, M, er maksimalt 12. Vi kan takle den ekstra plassen ved hjelp av bitfelt.

Forbedret eksempel

Enkeltminnets byte [4 byte]

Minneblokk opprettes flere av 4 byte.

Variabelen D1 av typen “Dato” tar 8 byte på en kompilator, mens et usignert heltall tar 4 byte.

Programmeringseksempel 3

Vi vil se et annet eksempel på hukommelsesforbruk uten å bruke litt felt.

1 2 3 4 5 6 7 8 9 10 11 12 1. 3 14 15 16 17 18 19 20 21 22 23 24 25 26 27

#inkludere struct tm usignert int hrs; usignert int min; usignert int sek; ; int main () struct tm t = 11, 30, 10; // erklæring om en variabel av brukerdefinert type. printf ("Tiden er %d: %d: %d \ n", t.HRS, t.Min, t.sek); printf ("størrelsen på klokken = %ld byte.\ n ", sizeof (struct tm)); retur 0;

Produksjon

Forklaring

Fra forrige beregning av datoen prøver vi å si at for å representere de maksimale sekundene på en time (60), er det bare et 6-bits minne som kreves av 4 byte eller 32 biter. Det er det samme også for å telle minuttene. Det er 60 minutter på en time. For å representere 60 i minnet, tar det bare 5 biter av 4 byte eller 32 biter. Så det fremgår av denne oppfatningen at resten av minnet er bortkastet i tilfelle dag og måned på en dato. Dette problemet vil bli løst ved hjelp av bitfeltet.

Programmering Eksempel 4

Her kan vi se en annen anvendelse av bitfelt.

1 2 3 4 5 6 7 8 9 10 11 12 1. 3 14 15 16 17 18 19 20 21 22 23 24 25 26 27

#inkludere struct tm usignert int HRS: 8; usignert int min: 10; usignert int sek: 10; ; int main () struct tm t = 11, 30, 10; // erklæring om en variabel av brukerdefinert type. printf ("Tiden er %d: %d: %d \ n", t.HRS, t.Min, t.sek); printf ("størrelsen på klokken = %ld byte.\ n ", sizeof (struct tm)); retur 0;

Produksjon

Forklaring

I dette programmeringseksemplet bruker vi bitfelt for å konsumere minne. Som vi ser av eksemplet, vil vi bruke bitfeltet (:) Etter å ha erklært hvert datamedlem av tidsdatatypen og prøver å konsumere biter på et minneplassering. Som et resultat vil vi se fra utgangsminnet konsumeres.

Konklusjon

Fra forrige erklæring er det tydelig at vi må bruke bitfeltet for å håndtere romkompleksitet på C -språket. Bitfelt hjelper oss med å fjerne ekstra bortkastet minnetildeling fra minnet for å håndtere romkompleksitet. Så vi må bruke bitfeltet på en veldig bevisst måte der det kreves. Ellers kan data bli bortkastet.