Phenquestions
Izpratne par izmēru:
Pirms mēs ienirstam operatora diskusijas lielumā, vispirms sapratīsim operatora nozīmi. Operatoru attēlo marķieris vai simbols, ko izmanto, lai veiktu tādas darbības kā saskaitīšana, atņemšana, reizināšana, dalīšana utt. pēc vērtībām vai mainīgajiem (operandi). Piemēram, “*” ir simbols, kas tiek izmantots, lai attēlotu reizināšanas operāciju, un tas darbojas uz diviem operandiem (rezultāts = a * b;). Šis ir binārā operatora piemērs.
Tomēr, ja operators darbojas tikai vienā operandā, mēs šādu operatoru saucam par vienotu operatoru. Operatora izmērs ir viens no unikālajiem operatoriem, kas pastāv C programmēšanas valodā, un acīmredzot tas darbojas tikai vienā operandā. Operatora lielums atgriež operanda lielumu. Tas nozīmē, ka no operatora Sizeof atgriešanās vērtības mēs varam skaidri pateikt, cik baitu piešķirti konkrētā operanda turēšanai datora atmiņā.
Datora atmiņa ir atmiņas vienību kolekcija (t.i.e. baits). Kad sizeof (int) atgriež četrus konkrētā datorsistēmā, mēs varam teikt, ka veselam skaitlim mainīgajam ir nepieciešami 4 baiti, lai saglabātu savu vērtību šīs konkrētās datorsistēmas atmiņā. Lūdzu, ņemiet vērā, ka operatora sizeof atgriešanās vērtība ir atkarīga arī no jūsu izmantotajām mašīnām (32 bitu sistēma vai 64 bitu sistēma).
Sintakse:
Sizeof (tips)Lielums (izteiksme)
Atgriešanās veids sizeof ir size_t.
Piemēri:
Tā kā mēs saprotam operatora lielumu un zinām sintaksi, apskatīsim pāris piemērus, kas palīdzēs mums labāk izprast jēdzienu.
- Iebūvēto tipu izmērs (piemērs1.c)
- Masīva izmērs (piemērs2.c)
- Sizeof lietotāja definētiem tipiem (piemērs3.c)
- Mainīgo lielums (piemērs4.c)
- Izteiksmes lielums (5. piemērs.c)
- Praktiska sizeof izmantošana (piemērs6.c)
Iebūvēto tipu izmērs (piemērs1.c):
Šajā programmā mēs redzēsim, kā operatora sizeof darbojas iebūvētiem datu tipiem, piemēram, int, char, float, double. Apskatīsim programmu un iznākumu.
# iekļautint main ()
printf ("char lielums =% ld \ n", sizeof (char));
printf ("int lielums =% ld \ n", sizeof (int));
printf ("Pludiņa izmērs =% ld \ n", sizeof (pludiņš));
printf ("Double izmērs =% ld \ n \ n", sizeof (double) lielums);
printf ("Īsās int lielums =% ld \ n", sizeof (īss int));
printf ("Garā int =% ld \ n" lielums (garais int) lielums);
printf ("Garās garās int lielums =% ld \ n", sizeof (garais garais int) lielums);
printf ("Garā dubultā izmērs =% ld \ n", sizeof (garais dubultā));
atgriešanās 0;
Masīva izmērs (piemērs2.c)
Šajā programmā mēs redzēsim, kā izmantot operatora sizeof dažādiem masīva veidiem. Masīva gadījumā operatora lielums atgriezīsies (Nr. elementu masīvā * Sizeof (masīva tips)). Piemēram, kad mēs deklarējam vesela skaitļa masīvu no 10 elementiem (int SmartPhones [10];), lielums (Smartphones) atgriezīsies:
(Nē. elementu viedtālruņos * sizeof (int)) = (10 * 4) = 40Apskatīsim programmu un iznākumu.
# iekļautint main ()
int Viedtālruņi [10];
char SmartPhoneNames [10];
dubultā SmartPhonesPrice [10];
printf ("int lielums =% ld \ n", sizeof (int));
printf ("char lielums =% ld \ n", sizeof (char));
printf ("Double izmērs =% ld \ n", sizeof (double) lielums);
/ * Uzziniet masīva izmēru * /
printf ("Viedtālruņu izmērs [10] =% ld \ n", lielums (Viedtālruņi));
printf ("SmartPhoneNames izmērs [10] =% ld \ n", sizeof (SmartPhoneNames) lielums);
printf ("SmartPhonesPrice izmērs [10] =% ld \ n", sizeof (SmartPhonesPrice));
atgriešanās 0;
Sizeof lietotāja definētiem tipiem (piemērs3.c):
Šajā piemērā mēs redzēsim, kā izmantot operatora sizeof lietotāja definētiem datu tipiem, piemēram, struktūrai un savienojumam. Izmantosim programmu un sapratīsim rezultātu.
Tagad, aplūkojot programmu, mēs varam manuāli aprēķināt SmartPhoneType lielumu. Kā redzat zemāk, SmartPhoneType ir struktūra, un tajā ir šādi elementi:
- Rakstzīmju tipa mainīgā skaits = 1 [sp_name]
- Vesela skaitļa mainīgā skaits = 1 [sp_version]
- Pludiņa tipa mainīgo skaits = 3 [sp_length, sp_width, sp_height]
No 1. piemēra mēs redzējām, ka:
-
- Rakstzīmes lielums ir 1 baits
- Vesela skaitļa lielums ir 4 baiti
- Pludiņa izmērs ir 4 baiti
Tāpēc, ja mēs saskaitām visu struktūras elementu lielumu, mums vajadzētu būt iespējai iegūt struktūras lielumu, t.e. SmartPhoneType. Tāpēc struktūras lielumam jābūt = (1 + 4 + 4 + 4 + 4) baiti = 17 baiti. Tomēr programmas izvadā teikts, ka struktūras lielums ir 20. Papildu 3 baiti (sp_name, kas ir raksturs, aizņem 4 baitus, nevis 1 baitu), kas struktūrai piešķirti struktūras polsterējuma dēļ.
# iekļaut/ * Izveidojiet lietotāja definētu struktūras veidu - SmartPhoneType * /
struct SmartPhoneType
char sp_name;
int sp_versija;
pludiņš sp_length;
pludiņš sp_width;
pludiņš sp_height;
Viedtālrunis;
/ * Definējiet lietotāja definētu savienības veidu - SmartPhoneUnionType * /
Union SmartPhoneUnionType
char sp_name;
int sp_versija;
pludiņš sp_length;
pludiņš sp_width;
pludiņš sp_height;
SmartPhone_u;
int main ()
/ * Uzziniet struktūras un savienojuma lielumu * /
printf ("struktūras lielums =% ld \ n", sizeof (viedtālrunis));
printf ("Savienojuma lielums =% ld \ n", sizeof (SmartPhone_u));
atgriešanās 0;
Mainīgo lielums (piemērs4.c):
Šis programmas piemērs parāda, ka operators sizeof var pieņemt arī mainīgo un atgriezt mainīgā lielumu.
# iekļautint main ()
/ * Paziņojiet char, int, float un dubultā tipa mainīgos un masīvu * /
char var_a, var_b [20];
int var_c, var_d [20];
pludiņš var_e, var_f [20];
dubultā var_g, var_h [20];
/ * Uzziniet mainīgo lielumu un masīva lielumu.
Šī programma parāda, ka mainīgais var arī
izmantot kā operatora operanda izmēru * /
/ * char, char mainīgais un char masīvs * /
printf ("char lielums =% ld \ n", sizeof (char));
printf ("Var_a lielums =% ld \ n", sizeof (var_a) lielums);
printf ("Var_b [20] =% ld \ n \ n" izmērs, sizeof (var_b) lielums);
/ * int, int mainīgā un int masīva lielums * /
printf ("int lielums =% ld \ n", sizeof (int));
printf ("Var_c =% ld \ n izmērs, sizeof (var_c) izmērs);
printf ("Var_d [20] =% ld \ n \ n" izmērs, sizeof (var_d) lielums);
/ * pludiņa, mainīgā mainīgā un pludiņa masīva lielums * /
printf ("Pludiņa izmērs =% ld \ n", sizeof (pludiņš));
printf ("Var_e =% ld \ n izmērs", sizeof (var_e) lielums);
printf ("Var_f [20] =% ld \ n \ n lielums, sizeof (var_f) lielums);
/ * dubultā, dubultā mainīgā un dubultā masīva izmērs * /
printf ("Double izmērs =% ld \ n", sizeof (double) lielums);
printf ("Var_g =% ld \ n izmērs", sizeof (var_g) lielums);
printf ("Var_h [20] =% ld \ n" izmērs, sizeof (var_h) lielums);
atgriešanās 0;
Izteiksmes lielums (5. piemērs.c):
Šajā programmas piemērā mēs parādīsim, ka operators sizeof var pieņemt izteiksmi un atgriezt iegūtās izteiksmes lielumu.
# iekļautint main ()
int var_a = 5, var_b = 3;
dubultā var_c = 2.5, var_d = 4.5;
printf ("int lielums =% ld \ n", sizeof (int));
printf ("Double izmērs =% ld \ n \ n", sizeof (double) lielums);
printf ("Var_a * var_b =% ld \ n izmērs", sizeof (var_a * var_b));
printf ("Var_c * var_d =% ld \ n" izmērs, sizeof (var_c * var_d));
/ * Šeit mēs reizinām veselu skaitli mainīgo ar dubultu mainīgo.
Tāpēc operatora sizeof atgriezīs maksimālā izmēra lielumu
mainīgais i.e. dubultā tipa mainīgais.* /
printf ("var_a * var_c =% ld \ n izmērs", sizeof (var_a * var_c));
atgriešanās 0;
Praktiska sizeof izmantošana (piemērs6.c):
Šis programmas piemērs palīdzēs jums izprast operatora sizeof praktisko lietojumu. Operators Sizeof ir ļoti noderīgs, vienlaikus piešķirot dinamisko atmiņu no kaudzes, izmantojot malloc. Apskatīsim programmu un iznākumu.
# iekļaut# iekļaut
typedef struct
char sp_name;
int sp_versija;
pludiņš sp_length;
pludiņš sp_width;
pludiņš sp_height;
SmartPhoneType;
int main ()
/ * Piešķiriet atmiņu kaudzes atmiņā piecu SmartPhoneType turēšanai
mainīgie.
* /
SmartPhoneType * SmartPhone_Ptr = (SmartPhoneType *) malloc (5 * sizeof (SmartPhoneType));
ja (SmartPhone_Ptr != NULL)
"Atmiņa piešķirta 5 SmartPhoneType struktūras mainīgajiem lielumiem"
kaudzes atmiņu.\ n ");
cits
printf ("Kļūda radās kaudzes atmiņas piešķiršanas laikā!");
atgriešanās 0;
Secinājums:
Sizeof ir svarīgs unārais operators C programmēšanas valodā. Tas mums palīdz noteikt primitīvu datu tipu, lietotāja definētu datu tipu, izteicienu utt. datora atmiņā. Operatoram Sizeof ir svarīga loma dinamiskās atmiņas piešķiršanā C, izmantojot malloc, calloc utt. kaudzes atmiņā.
