Phenquestions
Pochopenie Sizeof:
Predtým, ako sa ponoríme do diskusie o veľkosti operátora, najskôr pochopíme význam operátora. Prevádzkovateľa predstavuje token alebo symbol, ktorý sa používa na vykonanie operácie, ako je sčítanie, odčítanie, násobenie, delenie atď. na hodnoty alebo premenné (operandy). Napríklad „*“ je symbol, ktorý sa používa na reprezentáciu operácie násobenia, a funguje na dvoch operandoch (result = a * b;). Toto je príklad binárneho operátora.
Ak však operátor pracuje iba na jednom operande, nazývame ho ako unárny operátor. Operátor sizeof je jedným z unárnych operátorov, ktoré existujú v programovacom jazyku C, a zjavne funguje iba na jednom operande. Operátor sizeof vráti veľkosť operandu. To znamená, že z návratovej hodnoty operátora Sizeof môžeme jasne povedať, koľko bajtov alokovaných na zadržanie konkrétneho operandu v pamäti počítača.
Pamäť počítača je kolekcia pamäťových jednotiek (t.j.e. bajt). Keď sizeof (int) vráti štyri v konkrétnom počítačovom systéme, môžeme povedať, že celočíselnej premennej trvá 4 bajty, aby uchovala svoju hodnotu v pamäti konkrétneho počítačového systému. Upozorňujeme tiež, že návratová hodnota operátora sizeof závisí aj od strojov, ktoré používate (32-bitový systém alebo 64-bitový systém).
Syntax:
Veľkosť (typ)Sizeof (výraz)
Návratový typ sizeof je size_t.
Príklady:
Teraz, keď rozumieme operátoru sizeof a poznáme syntax, pozrime sa na pár príkladov, ktoré nám pomôžu lepšie pochopiť tento koncept.
- Veľkosť pre vstavané typy (príklad1.c)
- Veľkosť poľa (príklad 2.c)
- Veľkosť pre typy definované používateľom (príklad 3.c)
- Veľkosť premenných (príklad4.c)
- Veľkosť výrazu (príklad5.c)
- Praktické využitie veľkosti (príklad6.c)
Veľkosť pre vstavané typy (príklad1.c):
V tomto programe uvidíme, ako operátor sizeof funguje pre vstavané dátové typy ako int, char, float, double. Pozrime sa na program a výstup.
#includeint main ()
printf ("Veľkosť znaku =% ld \ n", veľkosť znaku (znak));
printf ("Velkost int =% ld \ n", velkost (int));
printf ("Veľkosť float =% ld \ n", sizeof (float));
printf ("Veľkosť double =% ld \ n \ n", sizeof (double));
printf ("Veľkosť krátkeho int =% ld \ n", sizeof (krátke int));
printf ("Velkost dlhej int =% ld \ n", velkost (dlha int));
printf ("Veľkosť long long int =% ld \ n", sizeof (long long int));
printf ("Veľkosť dlhej dvojitej =% ld \ n", veľkosť (dlhej dvojitej));
návrat 0;
Veľkosť poľa (príklad 2.c)
V tomto programe uvidíme, ako používať operátor sizeof pre rôzne typy polí. V prípade poľa sa vráti operátor sizeof (č. prvkov v poli * Sizeof (typ poľa)). Napríklad keď deklarujeme celočíselné pole s 10 prvkami (int SmartPhones [10];), vráti sa veľkosť (Smartphony):
(Nie. prvkov v inteligentných telefónoch * sizeof (int)) = (10 * 4) = 40Pozrime sa na program a výstup.
#includeint main ()
int SmartPhones [10];
char SmartPhoneNames [10];
zdvojnásobenie SmartPhonesPrice [10];
printf ("Velkost int =% ld \ n", velkost (int));
printf ("Veľkosť znaku =% ld \ n", veľkosť znaku (znak));
printf ("Veľkosť double =% ld \ n", sizeof (double));
/ * Zistite veľkosť poľa * /
printf ("Veľkosť SmartPhones [10] =% ld \ n", sizeof (SmartPhones));
printf ("Veľkosť SmartPhoneNames [10] =% ld \ n", sizeof (SmartPhoneNames));
printf ("Veľkosť SmartPhonesPrice [10] =% ld \ n", sizeof (SmartPhonesPrice)));
návrat 0;
Veľkosť pre typy definované používateľom (príklad3.c):
V tomto príklade uvidíme, ako používať operátor sizeof pre používateľom definované dátové typy, ako sú štruktúra a spojenie. Použime program a pochopme výstup.
Teraz sa pozrieme na program a môžeme manuálne vypočítať veľkosť SmartPhoneType. Ako vidíte nižšie, SmartPhoneType je štruktúra, ktorá obsahuje nasledujúce prvky:
- Počet premenných typu znakov = 1 [sp_name]
- Počet premenných typu celé číslo = 1 [sp_version]
- Počet premenných typu float = 3 [sp_length, sp_width, sp_height]
Z príkladu 1 sme videli, že:
-
- Veľkosť znaku je 1 bajt
- Veľkosť celého čísla je 4 bajty
- Veľkosť plaváka je 4 bajty
Ak teda spočítame veľkosť všetkých prvkov v štruktúre, mali by sme byť schopní získať veľkosť štruktúry, t.e. SmartPhoneType. Preto by veľkosť štruktúry mala byť = (1 + 4 + 4 + 4 + 4) bajtov = 17 bajtov. Avšak výstup programu hovorí, že veľkosť štruktúry je 20. Ďalšie 3 bajty (sp_name, čo je znak, namiesto 4 bajtov zaberajú 4 bajty) pridelené štruktúre kvôli polstrovaniu štruktúry.
#include/ * Vytvorenie používateľom definovaného typu štruktúry - SmartPhoneType * /
Štruktúra SmartPhoneType
char sp_name;
int sp_version;
float sp_length;
float sp_width;
float sp_height;
SmartPhone;
/ * Definujte typ spojenia definovaný používateľom - SmartPhoneUnionType * /
Union SmartPhoneUnionType
char sp_name;
int sp_version;
float sp_length;
float sp_width;
float sp_height;
SmartPhone_u;
int main ()
/ * Zistite veľkosť štruktúry a spojenia * /
printf ("Veľkosť štruktúry =% ld \ n", veľkosť (SmartPhone));
printf ("Veľkosť spojenia =% ld \ n", veľkosť (SmartPhone_u));
návrat 0;
Veľkosť premenných (príklad4.c):
Tento príkladový program ilustruje, že operátor sizeof je schopný prijať premennú tiež a vrátiť jej veľkosť.
#includeint main ()
/ * Deklarujte premennú a pole char, int, float a double type * /
char var_a, var_b [20];
int var_c, var_d [20];
float var_e, var_f [20];
double var_g, var_h [20];
/ * Zistite veľkosť premenných a poľa.
Tento program ukazuje, že premenná môže tiež
použiť ako veľkosť operandu operátora * /
/ * veľkosť znaku, premennej znaku a znakového poľa * /
printf ("Veľkosť znaku =% ld \ n", veľkosť znaku (znak));
printf ("Veľkosť var_a =% ld \ n", sizeof (var_a));
printf ("Veľkosť var_b [20] =% ld \ n \ n", sizeof (var_b));
/ * veľkosť int, int premennej a int poľa * /
printf ("Velkost int =% ld \ n", velkost (int));
printf ("Veľkosť var_c =% ld \ n", sizeof (var_c));
printf ("Veľkosť var_d [20] =% ld \ n \ n", sizeof (var_d));
/ * veľkosť float, float variable a float array * /
printf ("Veľkosť float =% ld \ n", sizeof (float));
printf ("Veľkosť var_e =% ld \ n", sizeof (var_e));
printf ("Veľkosť var_f [20] =% ld \ n \ n", sizeof (var_f));
/ * veľkosť dvojitého, dvojitého variabilného a dvojitého poľa * /
printf ("Veľkosť double =% ld \ n", sizeof (double));
printf ("Veľkosť var_g =% ld \ n", sizeof (var_g));
printf ("Veľkosť var_h [20] =% ld \ n", sizeof (var_h));
návrat 0;
Veľkosť výrazu (príklad5.c):
V tomto príkladovom programe ukážeme, že operátor sizeof môže tiež prijať výraz a vrátiť veľkosť výsledného výrazu.
#includeint main ()
int var_a = 5, var_b = 3;
double var_c = 2.5, var_d = 4.5;
printf ("Velkost int =% ld \ n", velkost (int));
printf ("Veľkosť double =% ld \ n \ n", sizeof (double));
printf ("Veľkosť var_a * var_b =% ld \ n", sizeof (var_a * var_b));
printf ("Veľkosť var_c * var_d =% ld \ n", sizeof (var_c * var_d));
/ * Tu vynásobíme celočíselnú premennú dvojitou premennou.
Preto operátor sizeof vráti veľkosť maximálnej veľkosti
premenná i.e. premenná dvojitého typu.* /
printf ("Veľkosť var_a * var_c =% ld \ n", sizeof (var_a * var_c));
návrat 0;
Praktické využitie veľkosti (príklad6.c):
Tento príkladový program vám pomôže pochopiť praktický prípad použitia operátora sizeof. Operátor Sizeof je veľmi užitočný pri alokovaní dynamickej pamäte z haldy pomocou programu malloc. Pozrime sa na program a výstup.
#include#include
typedef struct
char sp_name;
int sp_version;
float sp_length;
float sp_width;
float sp_height;
SmartPhoneType;
int main ()
/ * Alokácia pamäte v halde na uloženie piatich SmartPhoneType
premenné.
* /
SmartPhoneType * SmartPhone_Ptr = (SmartPhoneType *) malloc (5 * sizeof (SmartPhoneType));
ak (SmartPhone_Ptr != NULL)
"Pamäť pridelená pre 5 premenných štruktúry SmartPhoneType v systéme Windows
halda pamäte.\ n ");
inak
printf ("Počas alokácie pamäte haldy sa vyskytla chyba."!");
návrat 0;
Záver:
Sizeof je dôležitý unárny operátor v programovacom jazyku C. Pomáha nám pri určovaní veľkosti primitívnych dátových typov, používateľom definovaných dátových typov, výrazov atď. v pamäti počítača. Operátor Sizeof hrá dôležitú úlohu pri alokovaní dynamickej pamäte v C pomocou malloc, calloc atď. v pamäti haldy.
