C Programmering

Operatørstørrelse på C-sprog

Operatørstørrelse på C-sprog
I denne artikel vil vi lære om størrelsen på operatøren i C. Det er en meget anvendt unary operatør i den integrerede softwareudvikling, som hjælper os med at finde ud af størrelsen på operanden. Derfor hjælper returværdien af ​​operatørstørrelsen os med at forstå antallet af byte, der er allokeret i computerhukommelsen til at indeholde den bestemte variabel eller datatype.

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):

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.

#omfatte
int 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) = 40

Lad os se på programmet og output.

#omfatte
int 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.

#omfatte
int 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.

#omfatte
int 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.

Sådan vises OSD-overlay i fuldskærms Linux-apps og -spil
Afspilning af fuldskærmsspil eller brug af apps i distraktionsfri fuldskærmstilstand kan afskære dig fra relevante systemoplysninger, der er synlige i...
Top 5 spiloptagelseskort
Vi har alle set og elsket streaming af gameplay på YouTube. PewDiePie, Jakesepticye og Markiplier er kun nogle af de bedste spillere, der har tjent mi...
Sådan udvikler du et spil på Linux
For et årti siden ville ikke mange Linux-brugere forudsige, at deres foretrukne operativsystem en dag ville være en populær spilplatform til kommercie...