Størrelse på operatør på C -språk

I denne artikkelen skal vi lære om størrelsen på operatøren i C. Det er en mye brukt Unary -operatør i den innebygde programvareutviklingen, som hjelper oss å finne ut størrelsen på operanden. Derfor hjelper returverdien til den størrelsen på operatøren oss til å forstå antall byte som er tildelt i datamaskinminnet for å holde den spesielle variabelen eller datatypen.

Forstå størrelse av:

Før vi dykker inn i størrelsen på operatørdiskusjonen, la oss først forstå betydningen av operatøren. En operatør er representert med et symbol eller symbol som brukes til å utføre en operasjon som tillegg, subtraksjon, multiplikasjon, divisjon osv. på verdier eller variabler (operander). For eksempel er " *" symbolet som brukes til å representere multiplikasjonsoperasjonen, og det fungerer på to operander (resultat = a * b;). Dette er et eksempel på en binær operatør.

Imidlertid, hvis en operatør bare jobber med en operand, kaller vi en slik operatør som en unarisk operatør. Størrelsen på operatøren er en av de unary -operatørene som finnes på programmeringsspråk, og tilsynelatende opererer den bare på en operand. Størrelsen på operatøren returnerer størrelsen på operanden. Det betyr at vi fra returverdien til størrelsen på operatøren tydelig kan si hvor mange byte som er tildelt for å holde den spesielle operanden i datamaskinminnet.

Datamaskinens minne er en samling av minneenheter (i.e. byte). Når størrelse av (int) returnerer fire i et bestemt datasystem, kan vi si at en heltallvariabel tar 4 byte for å holde sin verdi i det spesifikke datasystemets minne. Vær også oppmerksom på at returverdien til størrelsen på operatøren også avhenger av maskinene du bruker (32-biters system eller 64-biters system).

Syntaks:

Størrelse av (type)
Størrelse av (uttrykk)

Returtypen størrelse er størrelse_t.

Eksempler:

Nå siden vi forstår størrelsen på operatøren og kjenner syntaksen, la oss se på et par eksempler, som vil hjelpe oss å forstå konseptet på en bedre måte.

• Størrelse for innebygde typer (eksempel1.c)
• Størrelse for matrise (eksempel2.c)
• Størrelse for brukerdefinerte typer (eksempel3.c)
• Størrelse for variabler (eksempel4.c)
• Størrelse for uttrykk (eksempel5.c)
• Praktisk bruk av størrelse av (eksempel6.c)

Størrelse for innebygde typer (eksempel1.c):

I dette programmet vil vi se hvordan størrelsen på operatøren fungerer for innebygde datatyper som Int, Char, Float, Double. La oss se på programmet og utdataene.

#inkludere
int main ()

printf ("størrelse på char = %ld \ n", størrelse av (char));
printf ("størrelse på int = %ld \ n", størrelse av (int));
printf ("størrelse på float = %ld \ n", størrelse av (float));
printf ("størrelse på dobbel = %ld \ n \ n", størrelse av (dobbel));
printf ("størrelse på kort int = %ld \ n", størrelse av (kort int));
printf ("størrelse på lang int = %ld \ n", størrelse av (lang int));
printf ("størrelse på lang lang int = %ld \ n", størrelse av (lang lang int));
printf ("størrelse på lang dobbel = %ld \ n", størrelse av (lang dobbel));
retur 0;

Størrelse for matrise (eksempel2.c)

I dette programmet vil vi se hvordan du bruker størrelsen på operatøren for forskjellige typer matrise. I tilfelle av en matrise vil størrelsen på operatøren komme tilbake (nei. av elementer i matrisen * sizeof (array type)). For eksempel, når vi erklærer en heltallstype med 10 elementer (Int -smarttelefoner [10];), vil størrelsen (smarttelefonene) komme tilbake:

(Nei. av elementer i smarttelefoner * størrelse av (int)) = (10 * 4) = 40

La oss se på programmet og utdataene.

#inkludere
int main ()

int smarttelefoner [10];
Char Smartphonenames [10];
Dobbelt smarttelefonprice [10];
printf ("størrelse på int = %ld \ n", størrelse av (int));
printf ("størrelse på char = %ld \ n", størrelse av (char));
printf ("størrelse på dobbel = %ld \ n", størrelse (dobbel));
/* Finn ut størrelsen på matrisen*/
printf ("størrelse på smarttelefoner [10] = %ld \ n", størrelse av (smarttelefoner));
printf ("størrelse på smartphonenames [10] = %ld \ n", størrelse av (smartphonenames));
printf ("størrelse på smarttelefonprice [10] = %ld \ n", størrelse av (smarttelefonprice));
retur 0;

Størrelse for brukerdefinerte typer (eksempel3.c):

I dette eksemplet vil vi se hvordan du bruker størrelse på operatør for brukerdefinerte datatyper som struktur og union. La oss bruke programmet og forstå utdataene.

Nå, når vi ser på programmet, og vi kan beregne størrelsen på Smartphonetype manuelt. Som du kan se nedenfor, er Smartphonetype en struktur, og den inneholder følgende elementer:

• Antall karaktertype variabel = 1 [sp_name]
• Antall heltallstype variabel = 1 [sp_versjon]
• Antall float -type variabler = 3 [sp_length, sp_width, sp_height]

Fra eksempel-1 har vi sett det:

• • Størrelsen på karakteren er 1 byte
  • Størrelsen på et heltall er 4 byte
  • Størrelsen på en flottør er 4 byte

Derfor, hvis vi legger opp størrelsen på alle elementene i strukturen, bør vi kunne få størrelsen på strukturen, i.e. Smartphonetype. Derfor skal størrelsen på strukturen være = (1 + 4 + 4 + 4 + 4) byte = 17 byte. Programutgangen sier imidlertid at strukturstørrelsen er 20. De ekstra 3 byte (SP_name, som er et tegn, tar 4 byte i stedet for 1 byte) tildelt for strukturen på grunn av strukturens polstring.

#inkludere
/* Opprett en brukerdefinert strukturtype - Smartphonetype*/
Struct Smartphonetype

char sp_name;
int sp_version;
float sp_length;
FLOAT SP_WIDTH;
float sp_height;
Smarttelefon;
/* Definer en brukerdefinert unionstype - SmartphoneunionType*/
Union SmartphoneunionType

char sp_name;
int sp_version;
float sp_length;
FLOAT SP_WIDTH;
float sp_height;
Smarttelefon_u;
int main ()

/* Finn ut størrelsen på struktur og union*/
printf ("størrelse på struktur = %ld \ n", størrelse av (smarttelefon));
printf ("størrelse på union = %ld \ n", størrelse av (smarttelefon_u));
retur 0;

Størrelse for variabler (eksempel4.c):

Dette eksempelprogrammet illustrerer at størrelsen på operatøren er i stand til å akseptere variabelen også og returnere størrelsen på variabelen.

#inkludere
int main ()

/ * Erklære røye, int, float og dobbel type variabel og matrise */
char var_a, var_b [20];
int var_c, var_d [20];
float var_e, var_f [20];
dobbel var_g, var_h [20];
/* Finn ut størrelsen på variabler og matrise.
Dette programmet viser at variabel også kan
brukes som operandstørrelse av operatøren*/
/* størrelse på røye, røye variabel og char array*/
printf ("størrelse på char = %ld \ n", størrelse av (char));
printf ("størrelse på var_a = %ld \ n", størrelse av (var_a));
printf ("størrelse på var_b [20] = %ld \ n \ n", størrelse av (var_b));
/* størrelse på int, int variabel og int -matrise*/
printf ("størrelse på int = %ld \ n", størrelse av (int));
printf ("størrelse på var_c = %ld \ n", størrelse av (var_c));
printf ("størrelse på var_d [20] = %ld \ n \ n", størrelse av (var_d));
/* størrelse på float, float -variabel og float -matrise*/
printf ("størrelse på float = %ld \ n", størrelse av (float));
printf ("størrelse på var_e = %ld \ n", størrelse av (var_e));
printf ("størrelse på var_f [20] = %ld \ n \ n", størrelse av (var_f));
/* størrelse på dobbel, dobbel variabel og dobbel matrise*/
printf ("størrelse på dobbel = %ld \ n", størrelse (dobbel));
printf ("størrelse på var_g = %ld \ n", størrelse av (var_g));
printf ("størrelse på var_h [20] = %ld \ n", størrelse av (var_h));
retur 0;

Størrelse for uttrykk (eksempel5.c):

I dette eksempelprogrammet vil vi demonstrere at størrelsen på operatøren også kan akseptere et uttrykk og returnere størrelsen på det resulterende uttrykket.

#inkludere
int main ()

int var_a = 5, var_b = 3;
dobbel var_c = 2.5, var_d = 4.5;
printf ("størrelse på int = %ld \ n", størrelse av (int));
printf ("størrelse på dobbel = %ld \ n \ n", størrelse av (dobbel));
printf ("størrelse på var_a * var_b = %ld \ n", størrelse av (var_a * var_b));
printf ("størrelse på var_c * var_d = %ld \ n", størrelse av (var_c * var_d));
/* Her multipliserer vi en heltallvariabel med en dobbel variabel.
Derfor vil størrelse på operatøren returnere størrelsen på maksimal størrelse
variabel i.e. Dobbelt type variabel.*/
printf ("størrelse på var_a * var_c = %ld \ n", størrelse av (var_a * var_c));
retur 0;

Praktisk bruk av størrelse av (eksempel6.c):

Dette eksempelprogrammet vil hjelpe deg å forstå en praktisk bruk av operatørens størrelse på. Størrelsen på operatøren er veldig nyttig mens du tildeler det dynamiske minnet fra Heap ved hjelp av Malloc. La oss se på programmet og utdataene.

#inkludere
#inkludere
typedef struct

char sp_name;
int sp_version;
float sp_length;
FLOAT SP_WIDTH;
float sp_height;
Smartphonetype;
int main ()

/* Tildel minnet i heapminnet for å holde fem smartfonetype
variabler.
*/
Smartphonetype * smarttelefon_ptr = (smartphonetype *) malloc (5 * sizeof (smartphonetype));
if (smartphone_ptr != Null)

printf ("minne tildelt for 5 smartfonetypestrukturvariabler i
haugminnet.\ n ");

ellers

printf ("Feil oppstod under tildeling av minneminne!");

retur 0;

Konklusjon:

Størrelsen på er en viktig unarisk operatør i programmeringsspråket C. Det hjelper oss med å bestemme størrelsen på primitive datatyper, brukerdefinerte datatyper, uttrykk osv. i dataminne. Størrelsen på operatøren spiller en viktig rolle i tildeling av dynamisk minne i C ved bruk av Malloc, Calloc, etc. I minnet.