Phenquestions
Suuruse mõistmine:
Enne kui arutame operaatori arutelu suurust, mõistkem kõigepealt operaatori tähendust. Operaatorit tähistab tunnus või sümbol, mida kasutatakse sellise toimingu sooritamiseks nagu liitmine, lahutamine, korrutamine, jagamine jne. väärtuste või muutujate järgi (operandid). Näiteks “*” on sümbol, mida kasutatakse korrutamistoimingu tähistamiseks, ja see töötab kahel operandil (tulemus = a * b;). See on binaaroperaatori näide.
Kui operaator töötab aga ainult ühe operandi peal, nimetame sellist operaatorit unaaroperaatoriks. Operaatori size on üks unaaroperaatoreid, mis eksisteerivad C-programmeerimiskeeles ja ilmselt töötab see ainult ühel operandil. Operaatori suurus tagastab operandi suuruse. See tähendab, et operaatori Sizeof tagastusväärtusest võime selgelt öelda, kui palju baite on eraldatud konkreetse operandi hoidmiseks arvuti mälus.
Arvuti mälu on mäluühikute kogu (st.e. bait). Kui sizeof (int) tagastab konkreetses arvutisüsteemis neli, võime öelda, et täisarvu muutujale kulub selle väärtuse hoidmiseks konkreetse arvutisüsteemi mälus 4 baiti. Pange tähele, et operaatori size tagastusväärtus sõltub ka teie kasutatavatest masinatest (32-bitine või 64-bitine süsteem).
Süntaks:
Suurus (tüüp)(Avaldise) suurus
Suuruse return tüüp on size_t.
Näited:
Kuna me mõistame operaatori suurust ja tunneme süntaksit, siis vaadakem paari näidet, mis aitavad meil mõistet paremini mõista.
- Sisseehitatud tüüpide suurus (näide1.c)
- Massiivi suurus (näide2.c)
- Kasutaja määratud tüüpide suurus (näide3.c)
- Muutujate suurus (näide4.c)
- Avaldise suurus (näide5.c)
- Praktiline sizeofi kasutamine (näide6.c)
Sisseehitatud tüüpide suurus (näide1.c):
Selles programmis näeme, kuidas operaatori size töötab sisseehitatud andmetüüpide puhul, näiteks int, char, float, double. Vaatame programmi ja väljundit.
# kaasataint main ()
printf ("char char =% ld \ n", sizeof (char));
printf ("int-i suurus =% ld \ n", sizeof (int));
printf ("Ujuki suurus =% ld \ n", suurus (ujuk));
printf ("Double of size =% ld \ n \ n", sizeof (double) suurus);
printf ("Lühikese int =% ld \ n" suurus, (lühike int) suurus);
printf ("Pika int =% ld \ n" suurus (pikk int) suurus);
printf ("Pika pika int =% ld \ n" suurus (pika pika int) suurus);
printf ("Pika topeli suurus =% ld \ n", sizeof (pika topelt));
tagastama 0;
Massiivi suurus (näide2.c)
Selles programmis näeme, kuidas kasutada operaatori sizeof erinevat tüüpi massiivide jaoks. Massiivi korral naaseb operaatori suurus (nr. massiivi elementide arv * Sizeof (massiivi tüüp)). Näiteks kui deklareerime kümnest elemendist koosneva täisarvu massiivi (int SmartPhones [10];), tagastatakse sizeof (nutitelefonid):
(Ei. elementidest nutitelefonides * sizeof (int)) = (10 * 4) = 40Vaatame programmi ja väljundit.
# kaasataint main ()
int Nutitelefonid [10];
char Nutitelefoninimed [10];
topelt SmartPhonesPrice [10];
printf ("int-i suurus =% ld \ n", sizeof (int));
printf ("char char =% ld \ n", sizeof (char));
printf ("Double of size =% ld \ n", sizeof (double) suurus);
/ * Uurige massiivi suurust * /
printf ("Nutitelefonide suurus [10] =% ld \ n", suurusof (Nutitelefonid));
printf ("SmartPhoneNimede suurus [10] =% ld \ n", sizeof (SmartPhoneNames) suurus);
printf ("SmartPhonesPricei suurus [10] =% ld \ n", sizeof (SmartPhonesPrice));
tagastama 0;
Kasutaja määratud tüüpide suurus (näide3.c):
Selles näites näeme, kuidas kasutada operaatori sizeof kasutaja määratletud andmetüüpide jaoks, nagu struktuur ja liit. Kasutame programmi ja mõistame väljundit.
Nüüd programmi vaadates saame käsitsi arvutada SmartPhoneType suuruse. Nagu allpool näete, on SmartPhoneType struktuur ja see sisaldab järgmisi elemente:
- Märgitüübi muutuja arv = 1 [sp_name]
- Täisarvu muutuja arv = 1 [sp_version]
- Ujuki tüüpi muutujate arv = 3 [sp_length, sp_width, sp_height]
Näite 1 järgi oleme näinud, et:
-
- Märgi suurus on 1 baiti
- Täisarvu suurus on 4 baiti
- Ujuki suurus on 4 baiti
Seega, kui liidame struktuuri kõigi elementide suuruse, peaksime suutma saada struktuuri suuruse, st.e. SmartPhoneType. Seetõttu peaks struktuuri suurus olema = (1 + 4 + 4 + 4 + 4) baiti = 17 baiti. Kuid programmi väljund ütleb, et struktuuri suurus on 20. 3 lisabaidi (sp_name, mis on märk, võtab 1 baiti asemel 4 baiti), mis on struktuurile eraldatud tänu struktuuri polsterdamisele.
# kaasata/ * Loo kasutaja määratud struktuuri tüüp - SmartPhoneType * /
struktureerida SmartPhoneType
char sp_name;
int sp_versioon;
ujuk sp_pikkus;
ujuk sp_width;
ujuk sp_height;
Nutitelefon;
/ * Määratlege kasutaja määratud liidu tüüp - SmartPhoneUnionType * /
Union SmartPhoneUnionType
char sp_name;
int sp_versioon;
ujuk sp_pikkus;
ujuk sp_width;
ujuk sp_height;
SmartPhone_u;
int main ()
/ * Uuri struktuuri ja liidu suurust * /
printf ("Struktuuri suurus =% ld \ n", sizeof (SmartPhone));
printf ("Liidu suurus =% ld \ n", sizeof (SmartPhone_u));
tagastama 0;
Muutujate suurus (näide4.c):
See näidisprogramm illustreerib, et operaatori size on võimeline ka muutujat aktsepteerima ja tagastama muutuja suuruse.
# kaasataint main ()
/ * Deklareerige char, int, float ja topelt tüüpi muutuja ja massiiv * /
char var_a, var_b [20];
int var_c, var_d [20];
ujuk var_e, var_f [20];
kahekordne var_g, var_h [20];
/ * Uuri muutujate ja massiivi suurust.
See programm näitab, et muutuja saab ka
kasutada operaatori operandi suuruseks * /
/ * char, char muutuja ja char array suurus * /
printf ("char char =% ld \ n", sizeof (char));
printf ("var_a suurus =% ld \ n", sizeof (var_a) suurus);
printf ("var_b [20] =% ld \ n \ n", sizeof (var_b) suurus);
/ * int, int muutuja ja int massiivi suurus * /
printf ("int-i suurus =% ld \ n", sizeof (int));
printf ("var_c =% ld \ n" suurus, (var_c) size);
printf ("var_d [20] =% ld \ n \ n", sizeof (var_d) suurus);
/ * ujuki, ujukmuutuja ja ujukimassiivi suurus * /
printf ("Ujuki suurus =% ld \ n", suurus (ujuk));
printf ("var_e suurus =% ld \ n", sizeof (var_e) suurus);
printf ("var_f [20] =% ld \ n \ n", sizeof (var_f) suurus);
/ * kahekordse, topeltmuutuja ja topeltmassiivi suurus * /
printf ("Double of size =% ld \ n", sizeof (double) suurus);
printf ("var_g =% ld \ n" suurus, (var_g) size);
printf ("var_h [20] =% ld \ n" suurus, (var_h) suurus);
tagastama 0;
Avaldise suurus (näide5.c):
Selles näidisprogrammis näitame, et operaator size saab ka avaldise aktsepteerida ja tagastada saadud avaldise suuruse.
# kaasataint main ()
int var_a = 5, var_b = 3;
topelt var_c = 2.5, var_d = 4.5;
printf ("int-i suurus =% ld \ n", sizeof (int));
printf ("Double of size =% ld \ n \ n", sizeof (double) suurus);
printf ("var_a * var_b =% ld \ n" suurus, sizeof (var_a * var_b));
printf ("var_c * var_d =% ld \ n" suurus, sizeof (var_c * var_d));
/ * Korrutame siin täisarvu muutuja kahekordse muutujaga.
Seetõttu tagastab operaatori sizeof suurima suuruse suuruse
muutuja i.e. topelt tüüpi muutuja.* /
printf ("var_a * var_c =% ld \ n" suurus, sizeof (var_a * var_c));
tagastama 0;
Praktiline sizeofi kasutamine (näide6.c):
See näidisprogramm aitab teil mõista operaatori size praktilist kasutamist. Operaator Sizeof on dünaamilise mälu eraldamiseks hunnikust malloci abil väga kasulik. Vaatame programmi ja väljundit.
# kaasata# kaasata
typedef struct
char sp_name;
int sp_versioon;
ujuk sp_pikkus;
ujuk sp_width;
ujuk sp_height;
SmartPhoneType;
int main ()
/ * Eraldage kuhja mällu mälu viie SmartPhoneType'i hoidmiseks
muutujad.
* /
SmartPhoneType * SmartPhone_Ptr = (SmartPhoneType *) malloc (5 * sizeof (SmartPhoneType));
kui (SmartPhone_Ptr != NULL)
printf ("Mälu eraldati 5 SmartPhoneType struktuuri muutujale aastal
kuhja mälu.\ n ");
muud
printf ("Hunniku mälu jaotamisel ilmnes viga!");
tagastama 0;
Järeldus:
Sizeof on C-programmeerimiskeeles oluline unaaroperaator. See aitab meil määrata primitiivsete andmetüüpide, kasutaja määratud andmetüüpide, avaldiste jms suurust. arvuti mällu. Operaatoril Sizeof on oluline roll C-dünaamilise mälu eraldamisel malloci, calloci jne abil. kuhja mällu.
