Mainīgie C++ programmēšanas valodā kalpo kā pamatelementi, lai apstrādātu un pārvaldītu datus, kam ir būtiska loma, manipulējot ar mainīgajiem C++ programmā. C++ programmēšanas valoda piedāvā stabilu veidu, kā pārvaldīt mainīgo redzamību dažādos tvērumos un kompilācijas vienībās, izmantojot statiskus globālos mainīgos. Statiskais globālais mainīgais, kas tiek deklarēts globālajā tvērumā, ir ierobežots līdz failam, kurā tas ir definēts “statiskā” specifikācijas dēļ. “Statiskais” atslēgvārds nodrošina, ka mainīgais saglabā savu vērtību visos funkciju izsaukumos šajā failā, tomēr paliek nepieejams un neredzams citiem failiem. Statiskie globālie mainīgie C++ ir ļoti svarīgi programmas stāvokļa pārvaldībā. Šajā rakstā ir apskatītas statisko globālo mainīgo sarežģītības, izceļot to īpašības, lietošanas gadījumus un iespējamās problēmas.
Statiskie mainīgie programmā C++
Programmā C++ statisku mainīgo var izveidot dažādās jomās, tostarp globālajā, lokālajā, nosaukumvietā vai klasēs. Tā pastāvēšana aptver visu programmas izpildes laiku no sākuma līdz beigām, nodrošinot, ka tās piešķiršana tiek saglabāta visā garumā. Vienkāršiem vārdiem sakot, atmiņa šiem mainīgajiem tiek piešķirta programmas sākumā un tiek noņemta, kad programmas izpilde beidzas. Ja statisko vērtību izmanto kopā ar mainīgo, tas ierobežo mainīgā redzamību saišu ziņā, un tas ir pieejams tikai programmai, kurā tas ir deklarēts.
Statisko mainīgo pielietojumi programmā C++
Statiskais globālais mainīgais nodrošina kontrolētu mehānismu, lai uzturētu stāvokli vai konfigurāciju, kas attiecas tikai uz definējošo failu. Failu tvēruma jēdziens, ko nosaka statiskie globālie mainīgie, veicina tīrāku modulāro programmēšanu, novēršot nevēlamas blakusparādības no ārējās saites, tādējādi radot apkopējamāku un kļūdām izturīgāku kodu. Statisko mainīgo var izmantot dažādos scenārijos, un tie ir uzskaitīti šādi:
1. scenārijs: skaitītājs vairākām funkcijām
Kad mainīgais tiek deklarēts ar statisko atslēgvārdu funkcijā, tas saglabā savu stāvokli vairākos vienas funkcijas izsaukumos. Šī spēja saglabāt mainīgā lieluma stāvokli var būt izdevīga īpašos apstākļos. Apskatīsim piemēru, lai izprastu skaitītāju vairākās funkcijās, izmantojot C++ statisko globālo mainīgo. Piemēra kods ir norādīts šādi:
#include
klases Skaitītājs {
Privāts:
statisks int globalCounter;
publiski:
spēkā neesošs incrementCounter ( ) {
++globalCounter;
}
int getCounterValue ( ) konst {
atgriezties globalCounter;
}
} ;
int Skaitītājs::globalCounter = 0 ;
int galvenais ( ) {
skaitītājs;
priekš ( int i = 0 ; i < 5 ; ++i ) {
counter.incrementCounter ( ) ;
}
int counterValue = counter.getCounterValue ( ) ;
std::cout << 'Skaitītāja vērtība ir: << pretvērtība << std::endl;
atgriezties 0 ;
}
Šis kods definē vienkāršu “Counter” klasi ar divām funkcijām: “incrementCounter”, kas palielina globālo skaitītāju par 1, un “getCounterValue”, kas atgriež globālā skaitītāja pašreizējo vērtību. Kods ietver arī galveno funkciju, kas izskaidro, kā izmantot klasi “Counter”. Tas izveido objektu “Counter”, palielina skaitītāju piecas reizes, izgūst tā vērtību un izdrukā to konsolē. Šajā implementācijā tiek izmantots viens globāls skaitītājs, ko koplieto visi “Counter” objekti. Tas ir vienkāršs un viegli saprotams, taču tas var nebūt piemērots situācijām, kad ir nepieciešami vairāki neatkarīgi skaitītāji. Skatiet šādu programmas izvadi:
Šajā piemērā varat novērot, ka statiskais mainīgais “globalCounter” saglabā savu stāvokli starp tādu funkciju izsaukumiem kā “incrementCounter” un “getCounterValue”, kas darbojas kā pastāvīgs skaitītājs vairākām viena faila funkcijām.
2. scenārijs: utilīta funkcija ir koplietota visos gadījumos
Ja klases dalībnieka funkcija ir definēta kā statiska, tā kļūst pieejama visiem klases gadījumiem. Tomēr tas nevar piekļūt instances dalībniekam, jo tam nav rādītāja. Lai labāk izprastu šo scenāriju, pievērsīsimies tālāk norādītajam atbilstošajam piemēram.
#includeklase UtilityClass {
publiski:
statiskā tukšuma lietderībaFunkcija ( ) {
std::cout << 'Tiek izsaukta funkcija Utility.' << std::endl;
}
} ;
klase MyClass {
publiski:
nederīga callUtilityFunction ( ) {
UtilityClass::utilītaFunkcija ( ) ;
}
} ;
int galvenais ( ) {
MyClass obj;
obj.callUtilityFunction ( ) ;
atgriezties 0 ;
}
Šis kods definē divas klases: “UtilityClass” un “MyClass”. “UtilityClass” ir publiska statiskā funkcija, ko sauc par “utilityFunction”, kas konsolē drukā “Utility funkcija tiek izsaukta”. “MyClass” ir publiska funkcija “callUtilityFunction”, kas izsauc “UtilityClass” funkciju “utilityFunction”.
Galvenā funkcija izveido “MyClass” objektu ar nosaukumu “obj”. Pēc tam tas izsauc objekta “obj” funkciju “callUtilityFunction”. Tas izraisa “UtilityClass” funkcijas “utilityFunction” izsaukšanu, kas drukā “Utility funkcija tiek izsaukta” konsolei. Skatiet šādu koda izvadi:
Šī pieeja novērš nepieciešamību pēc atsevišķiem objektiem un vienkāršo koda struktūru. Klase nodrošina divus veidus, kā piekļūt “utilītfunkcijai”. Viens veids ir tieši izmantot UtilityClass::utilityFunction() sintaksi, kas ir pieejama, neizveidojot objektu. Otrs veids ir caur objektu, kas izmanto obj.callUtilityFunction() dalībnieka funkciju, kas nodrošina vairāk konteksta un iespējamās papildu funkcionalitātes klasē. Šī pieeja līdzsvaro vienkāršību un elastību atkarībā no vēlamās lietderības funkcijas lietošanas veida.
3. scenārijs: klases tvērums statiskā globālajā mainīgajā
Neatkarīgi no klases gadījumu skaita, dalībnieks, kas klasē ir deklarēts kā statisks, pastāv tikai vienā eksemplārā. Tas attiecas gan uz datu dalībniekiem (mainīgajiem), gan uz dalībnieku funkcijām. Svarīgi ir tas, ka statisko datu elementa definīcijai ir jābūt ārpus klases deklarācijas, parasti faila tvērumā.
Šis ir statikas piemērs, kas tiek lietots gan datu dalībniekam, gan dalībnieka funkcijai programmā C++:
#includeklases skaitītājs {
publiski:
statisks int globalCount;
Skaitītājs ( ) {
++globalCount;
}
statiskā tukšuma drukāšanaGlobalCount ( ) {
std::cout << 'Globālais skaits ir: << globalCount << std::endl;
}
} ;
int Skaitītājs::globalCount = 0 ;
int galvenais ( ) {
Skaitītāja skaitītājs1;
Skaitītāja skaitītājs2;
Skaitītājs::printGlobalCount ( ) ;
atgriezties 0 ;
}
Kods definē klasi ar nosaukumu “Counter” ar privātu statisku dalībnieka mainīgo ar nosaukumu “globalCount” un divām publiskām dalībnieka funkcijām. Viens no tiem ir Counter (), kas ir konstruktora funkcija, kas palielina mainīgo “globalCount”. Otrs ir “printGlobalCount”, kas atgriež mainīgā “globalCount” pašreizējo vērtību. Kods ietver arī galveno funkciju. Šī funkcija izveido divus klases “Counter” objektus, kas tiek identificēti ar “counter1” un “counter2” nosaukumiem. Pēc mainīgā deklarācijas tas izsauc funkciju “Counter::printGlobalCount”, kas, iespējams, izdrukā mainīgā “globalCount” pašreizējo vērtību. Skatiet šādu izvades fragmentu:
Šajā piemērā mainīgais “globalCount” tiek deklarēts kā statisku datu dalībnieks klasē “Counter”. Tas nozīmē, ka pastāv tikai viena šī mainīgā kopija neatkarīgi no tā, cik “Counter” objektu ir izveidots. Skaitītāja()konstruktors palielina vērtību “globalCount” katram gadījumam, parādot tā kopīgo raksturu objektos. “printGlobalCount” ir statiska dalībnieka funkcija. Atcerieties, ka tas tiek darīts, izmantojot tieši klases nosaukumu (Counter::printGlobalCount). Izvade parāda, ka “globalCount” tiek palielināts, kā paredzēts, atspoguļojot koplietojamo stāvokli visos klases “Counter” gadījumos.
Secinājums
Visbeidzot, statiskie globālie mainīgie programmā C++ parādās kā daudzpusīgs rīks funkciju un failu stāvokļa pārvaldībai. To iekšējā saikne, noturīgais raksturs un kontrolētā informācijas apmaiņa padara tos par vērtīgiem līdzekļiem noteiktos programmēšanas scenārijos. Izprotot to īpašības, izpētot dažādus lietošanas gadījumus un apzinoties iespējamās nepilnības, izstrādātāji var efektīvi izmantot statiskos globālos mainīgos, uzlabojot koda modularitāti un atvieglojot saziņu starp dažādām savu projektu daļām. Pārdomāti apsverot un ievērojot labāko praksi, statiskos globālos mainīgos var izmantot, lai sniegtu pozitīvu ieguldījumu C++ programmu izstrādē un funkcionalitātē.