Phenquestions
Förstå storlek på:
Innan vi dyker in i storleken på operatörsdiskussionen, låt oss först förstå innebörden av operatören. En operatör representeras av en token eller symbol som används för att utföra en operation som addition, subtraktion, multiplikation, division osv. på värden eller variabler (Operander). Till exempel är "*" symbolen som används för att representera multiplikationsoperationen, och den fungerar på två operander (resultat = a * b;). Detta är ett exempel på en binär operatör.
Men om en operatör bara arbetar på en operand kallar vi en sådan operatör som en unary operatör. Operatörens storlek är en av de unara operatörerna som finns i C-programmeringsspråk och uppenbarligen fungerar den bara på en operand. Operatörens storlek returnerar operandens storlek. Det betyder, från returvärdet för Sizeof-operatören kan vi tydligt säga hur många byte som tilldelats för att hålla den specifika operanden i datorminnet.
En dators minne är en samling minnesenheter (i.e. byte). När sizeof (int) returnerar fyra i ett visst datorsystem kan vi säga att en heltalvariabel tar 4 byte för att hålla sitt värde i det specifika datorsystemets minne. Observera också att returvärdet för operatörens storlek också beror på vilka maskiner du använder (32-bitars eller 64-bitars system).
Syntax:
Storlek på (typ)Sizeof (uttryck)
Returtypen för sizeof är size_t.
Exempel:
Eftersom vi förstår operatörens storlek och känner till syntaxen, låt oss titta på några exempel som hjälper oss att förstå konceptet på ett bättre sätt.
- Sizeof för inbyggda typer (exempel1.c)
- Sizeof för Array (exempel2.c)
- Storlek för användardefinierade typer (exempel 3.c)
- Storlek för variabler (exempel 4.c)
- Storlek för uttryck (exempel 5.c)
- Praktisk användning av storlek på (exempel 6.c)
Sizeof för inbyggda typer (exempel1.c):
I det här programmet kommer vi att se hur storleken på operatören fungerar för inbyggda datatyper som int, char, float, double. Låt oss titta på programmet och utdata.
#omfattaint main ()
printf ("Storlek på char =% ld \ n", sizeof (char));
printf ("Storlek på int =% ld \ n", sizeof (int));
printf ("Storlek på float =% ld \ n", sizeof (float));
printf ("Storlek på dubbel =% ld \ n \ n", storlek på (dubbel));
printf ("Storlek på kort int =% ld \ n", storlek på (kort int));
printf ("Storlek på lång int =% ld \ n", storlek på (lång int));
printf ("Storlek på lång lång int =% ld \ n", storlek på (lång lång int));
printf ("Storlek på lång dubbel =% ld \ n", storlek på (lång dubbel));
returnera 0;
Sizeof för Array (exempel2.c)
I det här programmet kommer vi att se hur man använder storleken på operatören för olika typer av matriser. I händelse av en matris kommer operatörens storlek att returnera (Nej. av element i matrisen * Sizeof (arraytyp)). Till exempel när vi deklarerar en heltalstyp med 10 element (int SmartPhones [10];), kommer storleken på (Smartphones) att returnera:
(Nej. av element i SmartPhones * sizeof (int)) = (10 * 4) = 40Låt oss titta på programmet och utdata.
#omfattaint main ()
int Smarttelefoner [10];
char SmartPhoneNames [10];
dubbel SmartPhonesPrice [10];
printf ("Storlek på int =% ld \ n", sizeof (int));
printf ("Storlek på char =% ld \ n", sizeof (char));
printf ("Storlek på dubbel =% ld \ n", storlek på (dubbel));
/ * Ta reda på storleken på Array * /
printf ("Storlek på smarttelefoner [10] =% ld \ n", storlek på (smarttelefoner));
printf ("Storlek på SmartPhoneNames [10] =% ld \ n", sizeof (SmartPhoneNames));
printf ("Storlek på SmartPhonesPrice [10] =% ld \ n", sizeof (SmartPhonesPrice));
returnera 0;
Storlek för användardefinierade typer (exempel 3.c):
I det här exemplet kommer vi att se hur man använder sizeof-operatören för användardefinierade datatyper som struktur och union. Låt oss använda programmet och förstå resultatet.
Nu när vi tittar på programmet kan vi manuellt beräkna storleken på SmartPhoneType. Som du kan se nedan är SmartPhoneType en struktur och den innehåller följande element:
- Antal tecken typ variabel = 1 [sp_name]
- Antal variabler av heltalstyp = 1 [sp_version]
- Antal flytvariabler = 3 [sp_length, sp_width, sp_height]
Från exemplet 1 har vi sett att:
-
- Karaktärens storlek är 1 byte
- Storleken på ett heltal är 4 byte
- Storleken på en flottör är 4 byte
Därför, om vi adderar storleken på alla element i strukturen, borde vi kunna få storleken på strukturen, dvs.e. SmartPhoneType. Därför bör strukturens storlek vara = (1 + 4 + 4 + 4 + 4) byte = 17 byte. Men programutmatningen säger att strukturstorleken är 20. De extra 3 bytes (sp_name, vilket är ett tecken, tar 4 byte istället för 1 byte) som tilldelats för strukturen på grund av strukturfyllningen.
#omfatta/ * Skapa en användardefinierad strukturtyp - SmartPhoneType * /
struct SmartPhoneType
char sp_name;
int sp_version;
float sp_length;
float sp_width;
flyta sp_höjd;
SmartPhone;
/ * Definiera en användardefinierad facklig typ - SmartPhoneUnionType * /
Union SmartPhoneUnionType
char sp_name;
int sp_version;
float sp_length;
float sp_width;
flyta sp_höjd;
SmartPhone_u;
int main ()
/ * Ta reda på storleken på struktur och union * /
printf ("Storlek på struct =% ld \ n", sizeof (SmartPhone));
printf ("Unionens storlek =% ld \ n", sizeof (SmartPhone_u));
returnera 0;
Storlek för variabler (exempel 4.c):
Detta exempelprogram illustrerar att storleken på operatören kan acceptera variabeln och returnera storleken på variabeln.
#omfattaint main ()
/ * Deklarera char, int, float och dubbel typ variabel och array * /
char var_a, var_b [20];
int var_c, var_d [20];
flottör var_e, var_f [20];
dubbel var_g, var_h [20];
/ * Ta reda på storleken på variabler och array.
Detta program visar att variabeln också kan
användas som operandstorlek för operatör * /
/ * storleken på char, char variabel och char array * /
printf ("Storlek på char =% ld \ n", sizeof (char));
printf ("Storlek på var_a =% ld \ n", storlek på (var_a));
printf ("Storlek på var_b [20] =% ld \ n \ n", storlek på (var_b));
/ * storlek på int, int-variabel och int-array * /
printf ("Storlek på int =% ld \ n", sizeof (int));
printf ("Storlek på var_c =% ld \ n", sizeof (var_c));
printf ("Storlek på var_d [20] =% ld \ n \ n", storlek på (var_d));
/ * storlek på float, float variabel och float array * /
printf ("Storlek på float =% ld \ n", sizeof (float));
printf ("Storlek på var_e =% ld \ n", sizeof (var_e));
printf ("Storlek på var_f [20] =% ld \ n \ n", storlek på (var_f));
/ * storlek på dubbel, dubbel variabel och dubbel array * /
printf ("Storlek på dubbel =% ld \ n", storlek på (dubbel));
printf ("Storlek på var_g =% ld \ n", storlek på (var_g));
printf ("Storlek på var_h [20] =% ld \ n", storlek på (var_h));
returnera 0;
Storlek för uttryck (exempel 5.c):
I detta exempelprogram kommer vi att visa att storleksoperatören också kan acceptera ett uttryck och returnera storleken på det resulterande uttrycket.
#omfattaint main ()
int var_a = 5, var_b = 3;
dubbel var_c = 2.5, var_d = 4.5;
printf ("Storlek på int =% ld \ n", sizeof (int));
printf ("Storlek på dubbel =% ld \ n \ n", storlek på (dubbel));
printf ("Storlek på var_a * var_b =% ld \ n", sizeof (var_a * var_b));
printf ("Storlek på var_c * var_d =% ld \ n", sizeof (var_c * var_d));
/ * Här multiplicerar vi en helvariabel med en dubbel variabel.
Därför kommer operatörens storlek att returnera storleken på den maximala storleken
variabel i.e. dubbel typ variabel.* /
printf ("Storlek på var_a * var_c =% ld \ n", sizeof (var_a * var_c));
returnera 0;
Praktisk användning av storlek på (exempel 6.c):
Detta exempelprogram hjälper dig att förstå ett praktiskt användningsfall för operatörens storlek. Sizeof-operatören är mycket användbar när man tilldelar det dynamiska minnet från heap med malloc. Låt oss titta på programmet och utdata.
#omfatta#omfatta
typedef struct
char sp_name;
int sp_version;
float sp_length;
float sp_width;
flyta sp_höjd;
SmartPhoneType;
int main ()
/ * Tilldela minne i Heap-minnet för att hålla fem SmartPhoneType
variabler.
* /
SmartPhoneType * SmartPhone_Ptr = (SmartPhoneType *) malloc (5 * storlek på (SmartPhoneType));
om (SmartPhone_Ptr != NULL)
printf ("Minne tilldelat för 5 SmartPhoneType - strukturvariabler i
Heap-minnet.\ n ");
annan
printf ("Fel inträffade under tilldelningen av heapminne!");
returnera 0;
Slutsats:
Sizeof är en viktig unary operatör i C-programmeringsspråket. Det hjälper oss att bestämma storleken på primitiva datatyper, användardefinierade datatyper, uttryck, etc. i datorns minne. Sizeof-operatören spelar en viktig roll vid allokering av dynamiskt minne i C med malloc, calloc, etc. i Heap-minnet.
