Phenquestions
Pochopení Sizeof:
Než se ponoříme do diskuse o velikosti operátora, nejprve pochopíme význam operátora. Operátor je reprezentován tokenem nebo symbolem, který slouží k provedení operace, jako je sčítání, odčítání, násobení, dělení atd. na hodnoty nebo proměnné (operandy). Například „*“ je symbol, který se používá k reprezentaci operace násobení, a funguje na dva operandy (result = a * b;). Toto je příklad binárního operátoru.
Pokud však operátor pracuje pouze na jednom operandu, nazýváme jej jako unární operátor. Operátor sizeof je jedním z unárních operátorů, které existují v programovacím jazyce C, a podle všeho funguje pouze na jednom operandu. Operátor sizeof vrací velikost operandu. To znamená, že z návratové hodnoty operátoru Sizeof můžeme jasně říci, kolik bajtů je přiděleno k uložení konkrétního operandu v paměti počítače.
Paměť počítače je sbírka paměťových jednotek (tj.E. byte). Když sizeof (int) vrátí čtyři v konkrétním počítačovém systému, můžeme říci, že celočíselná proměnná trvá 4 bajty, aby uchovala svou hodnotu v paměti konkrétního počítačového systému. Mějte také na paměti, že návratová hodnota operátoru sizeof závisí také na strojích, které používáte (32bitový systém nebo 64bitový systém).
Syntax:
Velikost (typ)Sizeof (výraz)
Návratový typ sizeof je size_t.
Příklady:
Nyní, když rozumíme operátoru sizeof a známe syntaxi, podívejme se na pár příkladů, které nám pomohou lépe porozumět konceptu.
- Velikost pro vestavěné typy (příklad1.C)
- Velikost pole (příklad 2.C)
- Velikost pro uživatelem definované typy (příklad3.C)
- Velikost proměnných (příklad4.C)
- Velikost výrazu (příklad5.C)
- Praktické využití sizeof (příklad6.C)
Velikost pro vestavěné typy (příklad1.C):
V tomto programu uvidíme, jak operátor sizeof funguje pro vestavěné datové typy jako int, char, float, double. Podívejme se na program a výstup.
#zahrnoutint main ()
printf ("Velikost znaku =% ld \ n", sizeof (znak));
printf ("Velikost int =% ld \ n", sizeof (int));
printf ("Velikost float =% ld \ n", sizeof (float));
printf ("Velikost double =% ld \ n \ n", sizeof (double));
printf ("Velikost krátkého int =% ld \ n", sizeof (krátký int));
printf ("Velikost dlouhého int =% ld \ n", sizeof (dlouhý int));
printf ("Velikost long long int =% ld \ n", sizeof (long long int));
printf ("Velikost dlouhého dvojitého =% ld \ n", velikost (dlouhého dvojitého));
návrat 0;
Velikost pole (příklad 2.C)
V tomto programu uvidíme, jak použít operátor sizeof pro různé typy polí. V případě pole se vrátí operátor sizeof (č. prvků v poli * Sizeof (typ pole)). Například když deklarujeme celočíselné pole 10 prvků (int SmartPhones [10];), vrátí se sizeof (Smartphony):
(Ne. prvků v chytrých telefonech * sizeof (int)) = (10 * 4) = 40Podívejme se na program a výstup.
#zahrnoutint main ()
int SmartPhones [10];
char SmartPhoneNames [10];
zdvojnásobit SmartPhonesPrice [10];
printf ("Velikost int =% ld \ n", sizeof (int));
printf ("Velikost znaku =% ld \ n", sizeof (znak));
printf ("Velikost double =% ld \ n", sizeof (double));
/ * Zjistěte velikost pole * /
printf ("Velikost chytrých telefonů [10] =% ld \ n", sizeof (chytré telefony));
printf ("Velikost SmartPhoneNames [10] =% ld \ n", sizeof (SmartPhoneNames));
printf ("Velikost SmartPhonesPrice [10] =% ld \ n", sizeof (SmartPhonesPrice));
návrat 0;
Velikost pro uživatelem definované typy (příklad3.C):
V tomto příkladu uvidíme, jak použít operátor sizeof pro uživatelem definované datové typy, jako je struktura a sjednocení. Pojďme použít program a pochopit výstup.
Nyní, když se podíváme na program, můžeme velikost SmartPhoneType vypočítat ručně. Jak vidíte níže, SmartPhoneType je struktura a obsahuje následující prvky:
- Počet proměnných typu znaků = 1 [sp_name]
- Počet proměnných typu celé číslo = 1 [sp_version]
- Počet proměnných typu float = 3 [sp_length, sp_width, sp_height]
Z příkladu 1 jsme viděli, že:
-
- Velikost znaku je 1 bajt
- Velikost celého čísla je 4 bajty
- Velikost floatu je 4 bajty
Pokud tedy spočítáme velikost všech prvků ve struktuře, měli bychom být schopni získat velikost struktury, tj.E. SmartPhoneType. Proto by velikost struktury měla být = (1 + 4 + 4 + 4 + 4) bajtů = 17 bajtů. Výstup programu však říká, že velikost struktury je 20. Další 3 bajty (sp_name, což je znak, místo 4 bajtů bere 4 bajty) přidělené struktuře kvůli polstrování struktury.
#zahrnout/ * Vytvořit uživatelsky definovaný typ struktury - SmartPhoneType * /
strukturovat SmartPhoneType
char sp_name;
int sp_version;
float sp_length;
float sp_width;
float sp_height;
Chytrý telefon;
/ * Definujte uživatelem definovaný typ sjednocení - SmartPhoneUnionType * /
Union SmartPhoneUnionType
char sp_name;
int sp_version;
float sp_length;
float sp_width;
float sp_height;
SmartPhone_u;
int main ()
/ * Zjistěte velikost struktury a spojení * /
printf ("Velikost struktury =% ld \ n", sizeof (SmartPhone));
printf ("Velikost spojení =% ld \ n", sizeof (SmartPhone_u));
návrat 0;
Velikost proměnných (příklad4.C):
Tento ukázkový program ukazuje, že operátor sizeof je schopen přijmout proměnnou také a vrátit její velikost.
#zahrnoutint main ()
/ * Deklarujte proměnnou 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];
/ * Zjistěte velikost proměnných a pole.
Tento program ukazuje, že proměnná může také
použít jako velikost operandu operátora * /
/ * velikost char, char variable a char array * /
printf ("Velikost znaku =% ld \ n", sizeof (znak));
printf ("Velikost var_a =% ld \ n", sizeof (var_a));
printf ("Velikost var_b [20] =% ld \ n \ n", sizeof (var_b));
/ * velikost int, int proměnná a int pole * /
printf ("Velikost int =% ld \ n", sizeof (int));
printf ("Velikost var_c =% ld \ n", sizeof (var_c));
printf ("Velikost var_d [20] =% ld \ n \ n", sizeof (var_d));
/ * velikost float, float variable a float array * /
printf ("Velikost float =% ld \ n", sizeof (float));
printf ("Velikost var_e =% ld \ n", sizeof (var_e));
printf ("Velikost var_f [20] =% ld \ n \ n", sizeof (var_f));
/ * velikost dvojitého, dvojitého proměnného a dvojitého pole * /
printf ("Velikost double =% ld \ n", sizeof (double));
printf ("Velikost var_g =% ld \ n", sizeof (var_g));
printf ("Velikost var_h [20] =% ld \ n", sizeof (var_h));
návrat 0;
Velikost výrazu (příklad5.C):
V tomto ukázkovém programu ukážeme, že operátor sizeof může také přijmout výraz a vrátit velikost výsledného výrazu.
#zahrnoutint main ()
int var_a = 5, var_b = 3;
double var_c = 2.5, var_d = 4.5;
printf ("Velikost int =% ld \ n", sizeof (int));
printf ("Velikost double =% ld \ n \ n", sizeof (double));
printf ("Velikost var_a * var_b =% ld \ n", sizeof (var_a * var_b));
printf ("Velikost var_c * var_d =% ld \ n", sizeof (var_c * var_d));
/ * Zde vynásobíme celočíselnou proměnnou dvojitou proměnnou.
Operátor sizeof proto vrátí velikost maximální velikosti
proměnná i.E. proměnná typu double.* /
printf ("Velikost var_a * var_c =% ld \ n", sizeof (var_a * var_c));
návrat 0;
Praktické využití sizeof (příklad6.C):
Tento ukázkový program vám pomůže pochopit praktický případ použití operátoru sizeof. Operátor Sizeof je velmi užitečný při přidělování dynamické paměti z haldy pomocí malloc. Podívejme se na program a výstup.
#zahrnout#zahrnout
typedef struktura
char sp_name;
int sp_version;
float sp_length;
float sp_width;
float sp_height;
SmartPhoneType;
int main ()
/ * Přidělte paměť v haldě pro uložení pěti SmartPhoneType
proměnné.
* /
SmartPhoneType * SmartPhone_Ptr = (SmartPhoneType *) malloc (5 * sizeof (SmartPhoneType));
pokud (SmartPhone_Ptr != NULL)
printf ("Paměť přidělená 5 strukturním proměnným SmartPhoneType v systému Windows
paměť haldy.\ n ");
jiný
printf ("Během alokace paměti haldy došlo k chybě!");
návrat 0;
Závěr:
Sizeof je důležitý unární operátor v programovacím jazyce C. Pomáhá nám to při určování velikosti primitivních datových typů, uživatelem definovaných datových typů, výrazů atd. v paměti počítače. Operátor Sizeof hraje důležitou roli při přidělování dynamické paměti v C pomocí malloc, calloc atd. v paměti haldy.
