Ano ang isang Storage Class sa C ++ at mga uri nito?

Imbakan ng klase sa C ++ tumutukoy sa panghabambuhay at kakayahang makita ng variable / pagpapaandar. Ang panghabang buhay ay ang tagal hanggang kung saan mananatiling aktibo ang variable at ang kakayahang makita ang kakayahang mai-access ng isang variable mula sa iba't ibang mga module ng programa. Ito tumutulong upang subaybayan ang pagkakaroon ng isang partikular na variable sa panahon ng runtime ng isang programa. Sa blog ng mga klase sa pag-iimbak, titingnan namin ang iba't ibang mga klase sa pag-iimbak na ginamit sa C ++.

• Ano ang klase ng imbakan sa C ++?
• Mga uri ng klase ng imbakan
  • awtomatiko
  • magparehistro
  • static
  • panlabas
  • nababagabag

Magsimula na tayo.

Ano ang Class ng Storage sa C ++?

Ang bawat variable sa C ++ ay may uri ng data at klase ng imbakan. Tinutukoy ng uri ng data ang uri ng data na maaaring maimbak sa isang variable tulad ng int, float, char atbp. Kinokontrol ng storage class ang dalawang magkakaibang katangian ng isang variable: habang buhay at saklaw.

Makikita mo sana ang bawat variable ay may isang uri ng data, ngunit maaaring hindi mo nakita ang anumang klase ng imbakan na nakakabit sa isang variable sa ngayon. Sa totoo lang, kung hindi mo tinukoy ang isang klase ng imbakan, awtomatikong nagtatalaga ang tagatala ng isang default na klase ng imbakan dito. Ang klase ng imbakan ng isang variable ay nagbibigay ng impormasyon tungkol sa lokasyon ng imbakan ng variable sa memorya, default na paunang halaga, saklaw ng variable at habang buhay nito.

Mga uri ng Class ng Imbakan

Mayroong limang mga klase sa pag-iimbak sa isang C ++ Program:

• awtomatiko
• magparehistro
• static
• panlabas
• nababagabag

Talakayin natin nang detalyado ang bawat isa sa mga klase sa pag-iimbak.

Class ng Auto Storage

Ang awtomatikong (awtomatikong) klase ng pag-iimbak ay ang default na klase ng imbakan para sa lahat ng mga lokal na variable, na idineklara sa loob ng isang pag-andar o isang bloke. Ang auto keyword ay bihirang ginagamit habang nagsusulat ng a C ++ na programa .

Ang saklaw ng mga variable ng sasakyan ay nasa loob ng pag-andar o pag-block kung saan sila ay idineklara at hindi ito ma-access sa labas ng pagpapaandar o pag-block na iyon. Maaari din itong ma-access sa loob ng mga may punong bloke sa loob ng parent block / function kung saan idineklara ang variable ng auto.

Maaari mong ma-access ang mga variable ng sasakyan sa labas ng kanilang saklaw gamit ang isang variable ng pointer. Kailangan mong ituro ang parehong lokasyon ng memorya kung saan nakatira ang mga variable.

Ang buhay nito ay kapareho ng habang buhay ng pagpapaandar. Kapag natapos na ang pagpapatupad ng isang pagpapaandar, ang variable ay nawasak.

Bilang default, ang halaga ng basura ay nakatalaga sa kanila habang idinedeklara.

Syntax:

datatype var_name1 [= halaga]

o

auto datatype var_name1 [= halaga]

Sa halimbawa sa itaas, ang dalawang mga variable ay tinukoy na may parehong klase ng imbakan. Magagamit lamang ang auto upang tukuyin ang mga lokal na variable kabilang ang sa loob ng mga pag-andar.

Magrehistro ng Class ng Storage

Tulad ng ipinahihiwatig ng pangalan, ang klase sa pag-iimbak ng rehistro ay ginagamit upang ideklara ang mga variable ng rehistro. Ang lahat ng pag-andar ng variable ng rehistro ay kapareho ng variable ng auto maliban na sinusubukan ng tagatala na iimbak ang mga variable na ito sa rehistro ng microprocessor kung magagamit ang isang libreng rehistro. Kung ang isang libreng rehistro ay hindi magagamit, ang mga ito ay pagkatapos ay nakaimbak sa memorya lamang.

Kaya, ang mga pagpapatakbo sa mga variable ng rehistro ay mas mabilis kaysa sa iba pang mga variable na nakaimbak sa memorya sa panahon ng runtime ng programa.

Sa pangkalahatan, ilang mga variable na kailangang ma-access nang madalas sa isang programa ay idineklara sa loob ng rehistro ng imbakan na klase upang mapabuti ang oras ng pagpapatakbo ng programa. Ang address ng isang variable ng rehistro ay hindi maaaring makuha gamit ang mga payo.

Ang maximum na laki ng variable ay katumbas ng laki ng rehistro (hal. Isang salitang tinatayang). Hindi ito maaaring magkaroon ng isang unary na operator ng ‘&’ na inilapat dito dahil wala itong lokasyon ng memorya.

Syntax:

magparehistro ng datatype var_name1 [= halaga]

Halimbawa:

kung paano i-convert ang doble sa int sa java

{magparehistro int pi}

Ang pagtukoy sa 'rehistro' ay hindi nangangahulugang ang variable ay maiimbak sa isang rehistro. Maaaring itago ito sa isang rehistro depende sa mga paghihigpit sa hardware at pagpapatupad.

Tingnan natin ang isang halimbawa ng mga klase sa pagrehistro at awtomatikong pag-iimbak.

Halimbawa:

# isama ang paggamit ng namespace std // pagdedeklara ng variable na gagawin sa labas // ang isang intial na halaga ay maaari ding gawing x int x void autoStorageClass () {printf ('nDemonstrating auto classnn') // pagdedeklara ng isang variable ng auto (simpleng // Writing 'int a = 32' gumagana rin) int num = 32 // pag-print ng auto variable 'a' printf ('Value of the variable' num '' na idineklara bilang auto:% dn ', num) printf ( '------------------------------')} void registerStorageClass () {printf ('nDemonstrating register classnn') / / pagdedeklara ng isang variable ng rehistro magparehistro char c = 'G' // pagpi-print ng variable ng rehistro 'b' printf ('Halaga ng variable na' c '' 'na idineklara bilang rehistro:% dn', c) printf ('---- ---------------------------- ')} int main () {// To demonstr auto Storage Class autoStorageClass () // To demonstr magparehistro Storage Class registerStorageClass () bumalik 0}

Output:

Static Class ng Storage

Ang static na klase ng imbakan ay ginagamit upang ideklara mga static variable . Pinapanatili ng mga static variable ang kanilang halaga (hal. Ang huling halaga) kahit na wala sila sa kanilang saklaw. Ang mga static variable ay sinisimulan lamang ng isang beses &umiiral hanggang sa pagwawakas ng programa.

Ang memorya ay inilalaan nang isang beses lamang sa static variable at walang bagong memorya na inilalaan dahil hindi sila muling idineklara. Maaaring ma-access ang mga pandaigdigang variable na static saanman sa programa. Bilang default, nakatalaga sa kanila ang halagang 0 ng tagatala.

Sa C ++, kapag ginamit ang static sa isang miyembro ng data ng klase, sanhi ito ng isang kopya lamang ng kasapi na maibahagi ng lahat ng mga bagay ng klase nito.

Syntax:

static datatype var_name1 [= halaga]

Halimbawa:

#include void function (void) static int c = 5 // Global static variable main () {habang (c--) {function ()} ibalik ang 0} void function (void) {static int cnt = 2 cnt ++ std :: cout<< 'cnt is ' << cnt std::cout << ' and c is ' << c << std::endl } 

Output:

Klase ng Extern Storage

Ang klase ng panlabas na imbakan ay kinakailangan kapag ang mga variable ay kailangang ibahagi sa maraming mga file. Ang mga panlabas na variable ay may saklaw na pandaigdigan at ang mga variable na ito ay nakikita sa labas ng file kung saan idineklara ang mga ito. Ang variable ng extern ay nakikita ng lahat ng mga programa. Ginagamit ito kung ang dalawa o higit pang mga file ay nagbabahagi ng parehong variable o pagpapaandar.

Ang habambuhay na mga variable ng extern ay kasing haba ng natapos na ang program kung saan ito idineklara. Ang isang normal na variable ng mundo ay maaaring gawing extern din sa pamamagitan ng paglalagay ng keyword na 'extern' bago ang deklarasyon / kahulugan nito sa anumang pagpapaandar / block.

Kapag gumamit ka ng 'extern' ang variable ay hindi maaaring mapasimuno tulad ng ginagawa nito ay ituro ang variable na pangalan sa isang lokasyon ng imbakan na naunang natukoy.

Syntax

panlabas na uri ng data var_name1

Halimbawa

# isama ang int cnt extern void write_extern () main () {cnt = 5 write_extern ()}

Pangalawang File: support.cpp

# isama ang extern int cnt void write_extern (void) {std :: cout<< 'Count is ' << cnt << std::endl } 

Dito, ginagamit ang panlabas na keyword upang ideklara ang cnt sa isa pang file. I-compile ngayon ang dalawang file na ito tulad ng sumusunod at minus

pl sql tutorial para sa mga nagsisimula na may mga halimbawa

$ g ++ pangunahing.cpp suporta.cpp -o magsulat

Gumagawa ito ng maisusulat na programa na maisasagawa, subukang magpatupad ng pagsusulat at suriin ang resulta bilang mga sumusunod at minus

$. / sumulat

5

Patuloy sa klase ng pag-iimbak sa C ++, tingnan natin ang huling, ibig sabihin, Mutable storage class.

Mutable Storage Class

Nalalapat lamang ang nababagong specifier sa mga bagay sa klase, na nagpapahintulot sa isang miyembro ng isang bagay na i-override ang pagpapaandar ng miyembro ng const. Iyon ay, ang isang nababagabagong miyembro ay maaaring mabago ng isang pagpapaandar ng miyembro ng konstitusyon.

Sa wakas, tingnan natin ang talahanayan ng paghahambing upang maunawaan ang mga pagkakaiba sa pagitan ng iba't ibang mga klase sa pag-iimbak.

Ngayon pagkatapos dumaan sa mga nabanggit na C ++ na programa, maiintindihan mo kung ano ang iba't ibang mga klase sa imbakan sa C ++ at kung paano ipatupad ang mga ito. Inaasahan kong ang blog na ito ay may kaalaman at naidagdag na halaga sa iyo.

Sa gayon ay natapos na kami sa artikulong ito sa 'Mga klase sa imbakan sa C ++'.

Kung nais mong matuto nang higit pa, tingnan ang ni Edureka, isang pinagkakatiwalaang kumpanya sa pag-aaral sa online. Ang kurso sa pagsasanay at sertipikasyon ng Java J2EE at SOA ng Edureka ay idinisenyo upang sanayin ka para sa parehong core at advanced na mga konsepto ng Java kasama ang iba't ibang mga balangkas ng Java tulad ng Hibernate & Spring.

May tanong ba sa amin? Mangyaring banggitin ito sa seksyon ng mga komento ng blog na ito at babalikan ka namin sa lalong madaling panahon.