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 med å finne ut størrelsen på operanden. Derfor hjelper returverdien til operatørstørrelsen oss til å forstå antall byte som er tildelt i dataminnet for å holde den bestemte variabelen eller datatypen.

Forstå Sizeof:

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 token eller symbol som brukes til å utføre en operasjon som addisjon, 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 på en operand, kaller vi en slik operatør som en unary operatør. Sizeof-operatøren er en av de unary operatorene som finnes i C-programmeringsspråk, og tilsynelatende fungerer den bare på en operand. Operatørens størrelse returnerer størrelsen på operanden. Det betyr at fra returverdien til Sizeof-operatøren kan vi tydelig si hvor mange byte som er tildelt for å holde den spesielle operanden i dataminnet.

En datamaskins minne er en samling av minneenheter (i.e. byte). Når sizeof (int) returnerer fire i et bestemt datasystem, kan vi si at en heltalsvariabel tar 4 byte for å holde verdien 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-bits system eller 64-bits system).

Syntaks:

Sizeof (type)
Sizeof (uttrykk)

Returtypen for sizeof er size_t.

Eksempler:

Nå som 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.

• Sizeof for innebygde typer (eksempel1.c)
• Sizeof for Array (eksempel2.c)
• Sizeof for brukerdefinerte typer (eksempel3.c)
• Sizeof for variabler (eksempel4.c)
• Størrelse på uttrykk (eksempel 5.c)
• Praktisk bruk av størrelse på (eksempel 6.c)

Sizeof 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å røye =% ld \ n", størrelse på (røye));
printf ("Størrelse på int =% ld \ n", sizeof (int));
printf ("Størrelse på flottør =% ld \ n", størrelse på (flyt));
printf ("Størrelse på dobbelt =% ld \ n \ n", størrelse på (dobbelt));
printf ("Størrelse på kort int =% ld \ n", størrelse på (kort int));
printf ("Størrelse på lang int =% ld \ n", størrelse på (lang int));
printf ("Størrelse på lang lang int =% ld \ n", størrelse på (lang lang int));
printf ("Størrelse på lang dobbel =% ld \ n", størrelse på (lang dobbel));
retur 0;

Sizeof for Array (eksempel2.c)

I dette programmet vil vi se hvordan du bruker størrelsen på operatøren for forskjellige typer matriser. I tilfelle en matrise vil operatørens størrelse returnere (Nei. av elementer i matrisen * Sizeof (array type)). For eksempel, når vi erklærer et heltallstypematrise med 10 elementer (int SmartPhones [10];), vil størrelsen på (Smartphones) returnere:

(Nei. av elementer i smarttelefoner * sizeof (int)) = (10 * 4) = 40

La oss se på programmet og utdataene.

#inkludere
int main ()

int Smarttelefoner [10];
char SmartPhoneNames [10];
dobbelt SmartPhonesPrice [10];
printf ("Størrelse på int =% ld \ n", sizeof (int));
printf ("Størrelse på røye =% ld \ n", størrelse på (røye));
printf ("Størrelse på dobbelt =% ld \ n", størrelse på (dobbelt));
/ * Finn ut størrelsen på Array * /
printf ("Størrelse på smarttelefoner [10] =% ld \ n", størrelse på (smarttelefoner));
printf ("Størrelse på SmartPhoneNames [10] =% ld \ n", sizeof (SmartPhoneNames));
printf ("Størrelse på SmartPhonesPrice [10] =% ld \ n", sizeof (SmartPhonesPrice));
retur 0;

Sizeof for brukerdefinerte typer (eksempel3.c):

I dette eksemplet vil vi se hvordan du bruker sizeof-operator for brukerdefinerte datatyper som struktur og union. La oss bruke programmet og forstå utdataene.

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

• Antall tegnvariabler = 1 [sp_name]
• Antall variabler av heltall = 1 [sp_version]
• Antall variabler for flytype = 3 [sp_length, sp_width, sp_height]

Fra eksempel 1 har vi sett at:

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

Derfor, hvis vi legger sammen størrelsen på alle elementene i strukturen, bør vi kunne få størrelsen på strukturen, dvs.e. SmartPhoneType. Derfor bør størrelsen på strukturen være = (1 + 4 + 4 + 4 + 4) byte = 17 byte. Programoutgangen 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 strukturen på grunn av strukturpolstringen.

#inkludere
/ * Opprett en brukerdefinert strukturtype - SmartPhoneType * /
struct SmartPhoneType

char sp_name;
int sp_versjon;
flyte sp_length;
flyte sp_width;
flyte sp_height;
SmartPhone;
/ * Definer en brukerdefinert fagforeningstype - SmartPhoneUnionType * /
Union SmartPhoneUnionType

char sp_name;
int sp_versjon;
flyte sp_lengde;
flyte sp_width;
flyte sp_height;
SmartPhone_u;
int main ()

/ * Finn ut størrelsen på strukturen og foreningen * /
printf ("Størrelse på struct =% ld \ n", sizeof (SmartPhone));
printf ("Størrelse på union =% ld \ n", sizeof (SmartPhone_u));
retur 0;

Sizeof for variabler (eksempel4.c):

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

#inkludere
int main ()

/ * Deklarer char, int, float og double type variabel og array * /
char var_a, var_b [20];
int var_c, var_d [20];
flyte var_e, var_f [20];
dobbel var_g, var_h [20];
/ * Finn ut størrelsen på variabler og matrise.
Dette programmet viser at variabelen også kan
brukes som operandstørrelse på operatør * /
/ * størrelse på røye, røyevariabel og røyeoppstilling * /
printf ("Størrelse på røye =% ld \ n", størrelse på (røye));
printf ("Størrelse på var_a =% ld \ n", sizeof (var_a));
printf ("Størrelse på var_b [20] =% ld \ n \ n", størrelse på (var_b));
/ * størrelse på int, int-variabel og int-array * /
printf ("Størrelse på int =% ld \ n", sizeof (int));
printf ("Størrelse på var_c =% ld \ n", sizeof (var_c));
printf ("Størrelse på var_d [20] =% ld \ n \ n", størrelse på (var_d));
/ * størrelse på float, float variable og float array * /
printf ("Størrelse på flottør =% ld \ n", størrelse på (flyt));
printf ("Størrelse på var_e =% ld \ n", størrelse på (var_e));
printf ("Størrelse på var_f [20] =% ld \ n \ n", størrelse på (var_f));
/ * størrelse på dobbelt, dobbelt variabel og dobbelt array * /
printf ("Størrelse på dobbelt =% ld \ n", størrelse på (dobbelt));
printf ("Størrelse på var_g =% ld \ n", sizeof (var_g));
printf ("Størrelse på var_h [20] =% ld \ n", størrelse på (var_h));
retur 0;

Størrelse på uttrykk (eksempel 5.c):

I dette eksempelprogrammet vil vi demonstrere at sizeof-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;
dobbelt var_c = 2.5, var_d = 4.5;
printf ("Størrelse på int =% ld \ n", sizeof (int));
printf ("Størrelse på dobbelt =% ld \ n \ n", størrelse på (dobbelt));
printf ("Størrelse på var_a * var_b =% ld \ n", sizeof (var_a * var_b));
printf ("Størrelse på var_c * var_d =% ld \ n", sizeof (var_c * var_d));
/ * Her multipliserer vi en heltalsvariabel med en dobbel variabel.
Derfor vil størrelsen på operatøren returnere størrelsen på maksimal størrelse
variabel i.e. dobbel type variabel.* /
printf ("Størrelse på var_a * var_c =% ld \ n", sizeof (var_a * var_c));
retur 0;

Praktisk bruk av størrelse på (eksempel 6.c):

Dette eksempelprogrammet hjelper deg med å forstå en praktisk brukssak for operatørens størrelse. Sizeof-operatøren er veldig nyttig når han 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_versjon;
flyte sp_length;
flyte sp_width;
flyte sp_height;
SmartPhoneType;
int main ()

/ * Tildel minne i Heap-minnet for å holde fem SmartPhoneType
variabler.
* /
SmartPhoneType * SmartPhone_Ptr = (SmartPhoneType *) malloc (5 * størrelse på (SmartPhoneType));
hvis (SmartPhone_Ptr != NULL)

printf ("Minne tildelt for 5 SmartPhoneType strukturvariabler i
haugminnet.\ n ");

ellers

printf ("Det oppstod en feil under tildelingen av heapminne!");

retur 0;

Konklusjon:

The Sizeof er en viktig unary operatør i C-programmeringsspråket. Det hjelper oss med å bestemme størrelsen på primitive datatyper, brukerdefinerte datatyper, uttrykk osv. i dataminnet. Sizeof-operatøren spiller en viktig rolle i tildelingen av dynamisk minne i C ved bruk av malloc, calloc, etc. i Heap-minnet.