Ang mga variable sa C++ programming language ay nagsisilbing pangunahing mga bloke ng gusali upang pangasiwaan at pamahalaan ang data na gumaganap ng mahalagang papel sa pagmamanipula ng mga variable sa loob ng isang C++ na programa. Nag-aalok ang C++ programming language ng isang mahusay na paraan upang pamahalaan ang variable visibility sa iba't ibang saklaw at compilation unit gamit ang mga static na global variable. Ang isang static na global variable na idineklara sa pandaigdigang saklaw ay limitado sa file kung saan ito ay tinukoy dahil sa 'static' specifier. Tinitiyak ng 'static' na keyword na napanatili ng variable ang halaga nito sa mga function call sa loob ng file na iyon ngunit nananatiling hindi naa-access at hindi nakikita ng iba pang mga file. Ang mga static na global variable sa C++ ay mahalaga sa pamamahala sa estado ng programa. Sinasaliksik ng artikulong ito ang mga sali-salimuot ng mga static na global variable, na itinatampok ang kanilang mga katangian, mga kaso ng paggamit, at mga potensyal na hamon.
Mga Static na Variable sa C++
Sa C++, maaaring ma-instantiate ang isang static na variable sa loob ng iba't ibang saklaw kabilang ang global, local, namespace, o sa loob ng mga klase. Ang pag-iral nito ay sumasaklaw sa buong runtime ng programa mula simula hanggang katapusan, na tinitiyak na ang paglalaan nito ay napanatili sa kabuuan. Sa simpleng salita, ang memorya ay inilalaan sa mga variable na ito sa simula ng programa at ideallocate kapag natapos ang pagpapatupad ng programa. Kapag ginamit ang static sa isang variable, nililimitahan nito ang visibility ng variable sa mga tuntunin ng linkage, at naa-access lang ito para sa program kung saan ito idineklara.
Mga Application ng Static Variable sa C++
Ang static na global variable ay nagbibigay ng isang kinokontrol na mekanismo upang mapanatili ang isang estado o configuration na may kinalaman lamang sa pagtukoy ng file. Ang konsepto ng saklaw ng file na ipinapataw ng mga static na global variable ay nagpapadali sa isang mas malinis na modular programming sa pamamagitan ng pagpigil sa mga hindi gustong side effect mula sa external linkage, at sa gayon ay humahantong sa isang mas mapanatili at error-resistant na code. Ang static na variable ay maaaring gamitin sa iba't ibang mga sitwasyon at ang mga ito ay nakalista sa mga sumusunod:
Scenario 1: Counter Across Multiple Function
Kapag ang isang variable ay ipinahayag na may static na keyword sa loob ng isang function, pinapanatili nito ang estado nito sa maraming mga tawag sa parehong function. Ang kakayahang ito na mapanatili ang estado ng isang variable ay maaaring maging kapaki-pakinabang sa ilalim ng mga partikular na pangyayari. Tingnan natin ang isang halimbawa para maunawaan ang counter sa maraming function gamit ang isang C++ static global variable. Ang halimbawang code ay ibinigay tulad ng sumusunod:
#include
Counter ng klase {
pribado:
static int globalCounter;
publiko:
void incrementCounter ( ) {
++globalCounter;
}
int getCounterValue ( ) const {
bumalik globalCounter;
}
} ;
int Counter::globalCounter = 0 ;
int pangunahing ( ) {
Counter counter;
para sa ( int i = 0 ; i < 5 ; ++i ) {
counter.incrementCounter ( ) ;
}
int counterValue = counter.getCounterValue ( ) ;
std::cout << 'Ang halaga ng counter ay: ' << counterValue << std::endl;
bumalik 0 ;
}
Tinutukoy ng code na ito ang isang simpleng klase ng 'Counter' na may dalawang function: 'incrementCounter' na nagpapataas ng global counter ng 1 at 'getCounterValue' na nagbabalik ng kasalukuyang halaga ng global counter. Kasama rin sa code ang isang pangunahing function na nagpapaliwanag kung paano gamitin ang klase ng 'Counter'. Lumilikha ito ng object na 'Counter', dinaragdagan ang counter ng limang beses, kinukuha ang halaga nito, at ipi-print ito sa console. Gumagamit ang pagpapatupad na ito ng iisang pandaigdigang counter na ibinabahagi ng lahat ng object na 'Counter'. Ito ay simple at madaling maunawaan, ngunit maaaring hindi ito angkop para sa mga sitwasyon kung saan kailangan mo ng maraming independiyenteng counter. Tingnan ang sumusunod na output ng programa:
Sa halimbawang ito, maaari mong obserbahan na ang static na variable ng 'globalCounter' ay nagpapanatili ng katayuan nito sa pagitan ng mga tawag sa mga function tulad ng 'incrementCounter' at 'getCounterValue' na gumaganap bilang isang paulit-ulit na counter sa maraming function sa parehong file.
Sitwasyon 2: Ibinahagi ang Function ng Utility sa Mga Instance
Kapag ang function ng miyembro sa klase ay tinukoy bilang static, magiging available ito sa lahat ng instance ng klase. Gayunpaman, hindi nito ma-access ang isang miyembro ng instance dahil wala itong pointer. Isaalang-alang natin ang sumusunod na nauugnay na halimbawa upang magkaroon ng mas mahusay na pag-unawa sa sitwasyong ito:
#includeklase UtilityClass {
publiko:
static void utilityFunction ( ) {
std::cout << 'Ang function ng Utility ay tinatawag.' << std::endl;
}
} ;
klase MyClass {
publiko:
void callUtilityFunction ( ) {
UtilityClass::utilityFunction ( ) ;
}
} ;
int pangunahing ( ) {
MyClass obj;
obj.callUtilityFunction ( ) ;
bumalik 0 ;
}
Tinutukoy ng code na ito ang dalawang klase: 'UtilityClass' at 'MyClass'. Ang 'UtilityClass' ay may pampublikong static na function na tinatawag na 'utilityFunction' na nagpi-print ng 'The Utility function is called' sa console. Ang 'MyClass' ay may pampublikong function na tinatawag na 'callUtilityFunction' na tumatawag sa 'utilityFunction' function ng 'UtilityClass'.
Ang pangunahing function ay lumilikha ng isang bagay ng 'MyClass' na tinatawag na 'obj'. Pagkatapos ay tinawag nito ang function na 'callUtilityFunction' ng object na 'obj'. Ito ay nagiging sanhi ng 'utilityFunction' na function ng 'UtilityClass' na matawag na nagpi-print ng 'The Utility function ay tinatawag' sa console. Tingnan ang sumusunod na output ng code:
Tinatanggal ng diskarteng ito ang pangangailangan para sa hiwalay na mga bagay at pinapasimple ang istraktura ng code. Nagbibigay ang klase ng dalawang paraan upang ma-access ang 'utilityFunction'. Ang isang paraan ay direkta na gumagamit ng UtilityClass::utilityFunction() syntax na naa-access nang hindi gumagawa ng object. Ang iba pang paraan ay sa pamamagitan ng isang bagay na gumagamit ng obj.callUtilityFunction() function ng miyembro na nagbibigay-daan sa higit pang konteksto at potensyal na karagdagang functionality sa loob ng klase. Binabalanse ng diskarteng ito ang pagiging simple at flexibility, depende sa iyong gustong pattern ng paggamit para sa utility function.
Scenario 3: Saklaw ng Klase sa Static Global Variable
Anuman ang bilang ng mga pagkakataon ng klase, ang isang miyembro na idineklara bilang static sa loob ng isang klase ay umiiral lamang sa isang kopya. Nalalapat ito sa parehong mga miyembro ng data (mga variable) at mga function ng miyembro. Mahalaga, ang kahulugan ng isang static na miyembro ng data ay dapat mangyari sa labas ng deklarasyon ng klase, karaniwang nasa saklaw ng file.
Narito ang isang halimbawa ng static na inilapat sa parehong miyembro ng data at isang function ng miyembro sa C++:
#includeCounter ng klase {
publiko:
static int globalCount;
Kontra ( ) {
++globalCount;
}
static void printGlobalCount ( ) {
std::cout << 'Ang pandaigdigang bilang ay: ' << globalCount << std::endl;
}
} ;
int Counter::globalCount = 0 ;
int pangunahing ( ) {
Counter counter1;
Counter counter2;
Counter::printGlobalCount ( ) ;
bumalik 0 ;
}
Tinutukoy ng code ang isang klase na tinatawag na 'Counter' na may pribadong static na variable ng miyembro na pinangalanang 'globalCount' at dalawang pampublikong function ng miyembro. Ang isa ay Counter() na isang function ng constructor na nagdaragdag sa variable na 'globalCount'. Ang isa pa ay isang 'printGlobalCount' na nagbabalik ng kasalukuyang halaga ng variable na 'globalCount'. Kasama rin sa code ang isang pangunahing function. Ang function na ito ay lumilikha ng dalawang bagay ng 'Counter' na klase na kinilala ng 'counter1' at 'counter2' na mga pangalan. Pagkatapos ng variable na deklarasyon, tinatawag nito ang function na 'Counter::printGlobalCount' na maaaring nagpi-print ng kasalukuyang halaga ng variable na 'globalCount'. Tingnan ang sumusunod na snippet ng output:
Sa halimbawang ito, ang isang variable na 'globalCount' ay idineklara bilang isang static na miyembro ng data sa loob ng klase ng 'Counter'. Nangangahulugan ito na isang kopya lamang ng variable na ito ang umiiral, gaano man karaming 'Counter' na mga bagay ang nilikha. Ang counter()constructor ay dinaragdagan ang 'globalCount' para sa bawat pagkakataon, na nagpapakita ng nakabahaging kalikasan nito sa mga bagay. Ang 'printGlobalCount' ay isang static na function ng miyembro. Tandaan, ito ay ginagawa gamit ang pangalan ng klase nang direkta (Counter::printGlobalCount). Ang output ay nagpapakita na ang 'globalCount' ay dinadagdagan gaya ng inaasahan, na nagpapakita ng nakabahaging estado sa lahat ng mga pagkakataon ng 'Counter' na klase.
Konklusyon
Sa konklusyon, ang mga static na global variable sa C++ ay lumalabas bilang isang maraming nalalaman na tool upang pamahalaan ang estado sa mga function at file. Ang kanilang panloob na pagkakaugnay, paulit-ulit na kalikasan, at kontroladong pagbabahagi ng impormasyon ay ginagawa silang mahalagang asset sa ilang partikular na sitwasyon sa programming. Sa pamamagitan ng pag-unawa sa kanilang mga katangian, paggalugad sa magkakaibang mga kaso ng paggamit, at pagkilala sa mga potensyal na pitfalls, mabisang magagamit ng mga developer ang mga static na global variable, pagpapahusay sa modularity ng code at pagpapadali ng komunikasyon sa pagitan ng iba't ibang bahagi ng kanilang mga proyekto. Sa pamamagitan ng maingat na pagsasaalang-alang at pagsunod sa mga pinakamahuhusay na kagawian, ang mga static na global variable ay maaaring gamitin para positibong mag-ambag sa disenyo at functionality ng mga C++ program.