Forståelse af størrelse:
Før vi dykker ned i størrelsen på operatørdiskussionen, lad os først forstå betydningen af operatøren. En operatør er repræsenteret af et token eller symbol, der bruges til at udføre en operation som addition, subtraktion, multiplikation, division osv. på værdier eller variabler (Operander). For eksempel er "*" det symbol, der bruges til at repræsentere multiplikationsoperationen, og det fungerer på to operander (resultat = a * b;). Dette er et eksempel på en binær operatør.
Men hvis en operatør kun arbejder på en operand, kalder vi en sådan operatør som en unary operatør. Operatørens størrelse er en af de unære operatører, der findes i C-programmeringssprog, og tilsyneladende fungerer den kun på en operand. Operatørens størrelse returnerer størrelsen på operanden. Det betyder, fra returværdien af Sizeof-operatøren, kan vi tydeligt sige, hvor mange byte der er allokeret til at holde den bestemte operand i computerens hukommelse.
En computers hukommelse er en samling hukommelsesenheder (i.e. byte). Når sizeof (int) returnerer fire i et bestemt computersystem, kan vi sige, at en heltalsvariabel tager 4 byte for at holde sin værdi i det specifikke computersystems hukommelse. Bemærk også, at returværdien af operatørstørrelsen også afhænger af de maskiner, du bruger (32-bit system eller 64-bit system).
Syntaks:
Størrelse af (type)Sizeof (udtryk)
Returtypen for sizeof er size_t.
Eksempler:
Nu da vi forstår størrelsen på operatøren og kender syntaksen, lad os se på et par eksempler, som vil hjælpe os med at forstå konceptet på en bedre måde.
- Sizeof for indbyggede typer (eksempel1.c)
- Sizeof for Array (eksempel2.c)
- Sizeof for brugerdefinerede typer (eksempel3.c)
- Sizeof for variabler (eksempel 4.c)
- Sizeof for udtryk (eksempel 5.c)
- Praktisk anvendelse af størrelse af (eksempel 6.c)
Sizeof for indbyggede typer (eksempel1.c):
I dette program ser vi, hvordan operatørens størrelse fungerer for indbyggede datatyper som int, char, float, double. Lad os se på programmet og output.
#omfatteint main ()
printf ("Størrelse af char =% ld \ n", sizeof (char));
printf ("Størrelse på int =% ld \ n", sizeof (int));
printf ("floatstørrelse =% ld \ n", sizeof (float));
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 dobbelt =% ld \ n", størrelse på (lang dobbelt));
returnere 0;
Sizeof for Array (eksempel2.c)
I dette program vil vi se, hvordan man bruger størrelsen på operatoren til forskellige typer array. I tilfælde af en matrix returnerer operatorens størrelse (Nej. af elementer i arrayet * Sizeof (array type)). For eksempel, når vi erklærer et array med et helt tal på 10 elementer (int SmartPhones [10];), returnerer størrelsen på (Smartphones):
(Ingen. af elementer i SmartPhones * størrelse af (int)) = (10 * 4) = 40Lad os se på programmet og output.
#omfatteint main ()
int SmartPhones [10];
char SmartPhoneNames [10];
dobbelt SmartPhonesPrice [10];
printf ("Størrelse af int =% ld \ n", størrelse af (int));
printf ("Størrelse af char =% ld \ n", sizeof (char));
printf ("Størrelse på dobbelt =% ld \ n", størrelse på (dobbelt));
/ * Find ud af størrelsen på Array * /
printf ("SmartPhones størrelse [10] =% ld \ n", størrelse af (SmartPhones));
printf ("Størrelse på SmartPhoneNames [10] =% ld \ n", sizeof (SmartPhoneNames));
printf ("Størrelse på SmartPhonesPrice [10] =% ld \ n", sizeof (SmartPhonesPrice));
returnere 0;
Sizeof for brugerdefinerede typer (eksempel3.c):
I dette eksempel vil vi se, hvordan man bruger sizeof operator til brugerdefinerede datatyper som struktur og union. Lad os bruge programmet og forstå output.
Ser vi på programmet, og vi kan manuelt beregne størrelsen på SmartPhoneType. Som du kan se nedenfor, er SmartPhoneType en struktur, og den indeholder følgende elementer:
- Antal variabler for tegntype = 1 [sp_name]
- Antal variabler af heltalstype = 1 [sp_version]
- Antal float-type variabler = 3 [sp_length, sp_width, sp_height]
Fra eksemplet 1 har vi set, at:
-
- Karakterstørrelsen er 1 byte
- Størrelsen på et heltal er 4 byte
- Størrelsen på en float er 4 byte
Derfor, hvis vi sammenlægger størrelsen på alle elementerne i strukturen, skal vi være i stand til at få størrelsen på strukturen, dvs.e. SmartPhoneType. Derfor skal strukturens størrelse være = (1 + 4 + 4 + 4 + 4) bytes = 17 byte. Men programoutputtet siger, at strukturstørrelsen er 20. De ekstra 3 byte (sp_name, som er et tegn, tager 4 byte i stedet for 1 byte) tildelt til strukturen på grund af strukturpolstringen.
#omfatte/ * Opret en brugerdefineret strukturtype - SmartPhoneType * /
struct SmartPhoneType
char sp_name;
int sp_version;
flyde sp_længde;
flyde sp_bredde;
flyde sp_højde;
SmartPhone;
/ * Definer en brugerdefineret fagforeningstype - SmartPhoneUnionType * /
Union SmartPhoneUnionType
char sp_name;
int sp_version;
flyde sp_længde;
flyde sp_bredde;
flyde sp_højde;
SmartPhone_u;
int main ()
/ * Find ud af størrelsen på struktur og union * /
printf ("Størrelse på struct =% ld \ n", sizeof (SmartPhone));
printf ("Unionens størrelse =% ld \ n", sizeof (SmartPhone_u));
returnere 0;
Sizeof for variabler (eksempel 4.c):
Dette eksempelprogram illustrerer, at operatorens størrelse er i stand til også at acceptere variablen og returnere størrelsen på variablen.
#omfatteint main ()
/ * Erklær variabel og array med char, int, float og dobbelt type * /
char var_a, var_b [20];
int var_c, var_d [20];
flyde var_e, var_f [20];
dobbelt var_g, var_h [20];
/ * Find ud af størrelsen på variabler og array.
Dette program viser, at variabel også kan
bruges som operandstørrelse af operatør * /
/ * størrelse af char, char variabel og char array * /
printf ("Størrelse af char =% ld \ n", sizeof (char));
printf ("Størrelse på var_a =% ld \ n", sizeof (var_a));
printf ("Størrelse på var_b [20] =% ld \ n \ n", størrelse af (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 af var_d [20] =% ld \ n \ n", størrelse af (var_d));
/ * størrelse på float, float variabel og float array * /
printf ("floatstørrelse =% ld \ n", sizeof (float));
printf ("Størrelse af var_e =% ld \ n", størrelse af (var_e));
printf ("Størrelse af var_f [20] =% ld \ n \ n", størrelse af (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 af var_h [20] =% ld \ n", størrelse af (var_h));
returnere 0;
Sizeof for udtryk (eksempel 5.c):
I dette eksempelprogram vil vi demonstrere, at sizeof-operatøren også kan acceptere et udtryk og returnere størrelsen på det resulterende udtryk.
#omfatteint main ()
int var_a = 5, var_b = 3;
dobbelt var_c = 2.5, var_d = 4.5;
printf ("Størrelse af int =% ld \ n", størrelse af (int));
printf ("Størrelse på dobbelt =% ld \ n \ n", størrelse på (dobbelt));
printf ("Størrelse af var_a * var_b =% ld \ n", størrelse af (var_a * var_b));
printf ("Størrelse på var_c * var_d =% ld \ n", sizeof (var_c * var_d));
/ * Her multiplicerer vi et heltal med en dobbelt variabel.
Derfor returnerer operatørstørrelsen størrelsen på den maksimale størrelse
variabel i.e. dobbelt variabel.* /
printf ("Størrelse på var_a * var_c =% ld \ n", sizeof (var_a * var_c));
returnere 0;
Praktisk anvendelse af størrelse på (eksempel 6.c):
Dette eksempelprogram hjælper dig med at forstå en praktisk anvendelse af operatørens størrelse. Sizeof-operatøren er meget nyttig, når den allokerer den dynamiske hukommelse fra heap ved hjælp af malloc. Lad os se på programmet og output.
#omfatte#omfatte
typedef struct
char sp_name;
int sp_version;
flyde sp_længde;
flyde sp_bredde;
flyde sp_højde;
SmartPhoneType;
int main ()
/ * Tildel hukommelse i Heap-hukommelsen til at rumme fem SmartPhoneType
variabler.
* /
SmartPhoneType * SmartPhone_Ptr = (SmartPhoneType *) malloc (5 * størrelse af (SmartPhoneType));
hvis (SmartPhone_Ptr != NULL)
printf ("Hukommelse tildelt til 5 SmartPhoneType strukturvariabler i
bunkehukommelsen.\ n ");
andet
printf ("Der opstod en fejl under tildelingen af hukommelseshukommelsen!");
returnere 0;
Konklusion:
Sizeof er en vigtig unary operatør i C-programmeringssproget. Det hjælper os med at bestemme størrelsen på primitive datatyper, brugerdefinerede datatyper, udtryk osv. i computerens hukommelse. Sizeof-operatøren spiller en vigtig rolle i tildelingen af dynamisk hukommelse i C ved hjælp af malloc, calloc osv. i Heap-hukommelsen.