C++ programavimo kalbos kintamieji yra pagrindiniai elementai, skirti tvarkyti ir valdyti duomenis, kurie atlieka esminį vaidmenį manipuliuojant kintamaisiais C++ programoje. C++ programavimo kalba yra patikimas būdas valdyti kintamųjų matomumą įvairiose srityse ir kompiliavimo vienetuose naudojant statinius visuotinius kintamuosius. Statinis visuotinis kintamasis, kuris deklaruojamas visuotinėje srityje, yra apribotas failu, kuriame jis yra apibrėžtas dėl „statinės“ specifikacijos. „Statinis“ raktinis žodis užtikrina, kad kintamasis išlaikytų savo vertę per funkcijų iškvietimą tame faile, tačiau liktų nepasiekiamas ir nematomas kitiems failams. Statiniai pasauliniai kintamieji C++ yra labai svarbūs valdant programos būseną. Šiame straipsnyje nagrinėjami statinių pasaulinių kintamųjų sudėtingumai, pabrėžiamos jų savybės, naudojimo atvejai ir galimi iššūkiai.
Statiniai kintamieji C++
C++ kalboje statinis kintamasis gali būti pavaizduotas įvairiose srityse, įskaitant globalią, vietinę, vardų erdvę arba klasėse. Jos egzistavimas apima visą programos vykdymo laiką nuo pradžios iki pabaigos, užtikrinant, kad jos paskirstymas būtų išlaikytas. Paprastais žodžiais tariant, atmintis šiems kintamiesiems priskiriama programos pradžioje ir atlaisvinama, kai programos vykdymas baigiasi. Kai statinis naudojamas su kintamuoju, jis riboja kintamojo matomumą susiejimo požiūriu ir pasiekiamas tik tai programai, kurioje jis deklaruojamas.
Statinių kintamųjų taikymas C++
Statinis visuotinis kintamasis suteikia valdomą mechanizmą, leidžiantį palaikyti būseną arba konfigūraciją, kuri yra svarbi tik apibrėžiančiam failui. Failų apimties samprata, kurią nustato statiniai visuotiniai kintamieji, palengvina švaresnį modulinį programavimą, užkertant kelią nepageidaujamam išorinio susiejimo šalutiniam poveikiui ir taip sukuriamas labiau prižiūrimas ir klaidoms atsparesnis kodas. Statinis kintamasis gali būti naudojamas įvairiuose scenarijuose ir yra išvardytas taip:
1 scenarijus: kelių funkcijų skaitiklis
Kai kintamasis deklaruojamas naudojant statinį raktinį žodį funkcijoje, jis išsaugo savo būseną keliems tos pačios funkcijos iškvietimams. Šis gebėjimas išlaikyti kintamojo būseną gali būti naudingas tam tikromis aplinkybėmis. Pažvelkime į pavyzdį, kad suprastume kelių funkcijų skaitiklį naudojant C++ statinį visuotinį kintamąjį. Kodo pavyzdys pateikiamas taip:
#include
klasės skaitiklis {
privatus:
statinis int globalCounter;
viešas:
tuščias prieaugio skaitiklis ( ) {
++globalCounter;
}
int getCounterValue ( ) konst {
grąžinti globalCounter;
}
} ;
int Skaitiklis::globalCounter = 0 ;
tarp pagrindinis ( ) {
Skaitiklis;
dėl ( int i = 0 ; i < 5 ; ++i ) {
skaitiklis.incrementCounter ( ) ;
}
int counterValue = counter.getCounterValue ( ) ;
std::cout << 'Skaitiklio vertė yra: ' << priešpriešinė vertė << std::endl;
grąžinti 0 ;
}
Šis kodas apibrėžia paprastą „Counter“ klasę su dviem funkcijomis: „incrementCounter“, kuri padidina visuotinį skaitiklį 1 ir „getCounterValue“, kuri grąžina pasaulinio skaitiklio dabartinę vertę. Kode taip pat yra pagrindinė funkcija, paaiškinanti, kaip naudoti „Counter“ klasę. Jis sukuria objektą „Counter“, padidina skaitiklį penkis kartus, nuskaito jo vertę ir išspausdina jį į konsolę. Šis įgyvendinimas naudoja vieną visuotinį skaitiklį, kurį bendrina visi skaitiklio objektai. Tai paprasta ir lengvai suprantama, tačiau ji gali netikti situacijose, kai reikia kelių nepriklausomų skaitiklių. Peržiūrėkite šią programos išvestį:
Šiame pavyzdyje galite pastebėti, kad statinis kintamasis „globalCounter“ išlaiko savo būseną tarp tokių funkcijų kaip „incrementCounter“ ir „getCounterValue“, kurios veikia kaip nuolatinis kelių tame pačiame faile esančių funkcijų skaitiklis.
2 scenarijus: naudingumo funkcija bendrinama įvairiais atvejais
Kai klasės nario funkcija apibrėžiama kaip statinė, ji tampa prieinama visiems klasės egzemplioriams. Tačiau jis negali pasiekti egzemplioriaus nario, nes neturi žymeklio. Kad geriau suprastume šį scenarijų, panagrinėkime šį atitinkamą pavyzdį:
#includeklasė UtilityClass {
viešas:
statinė tuščioji priemonėFunkcija ( ) {
std::cout << 'Pavadinama funkcija.' << std::endl;
}
} ;
klasė MyClass {
viešas:
negalioja skambučio funkcija ( ) {
UtilityClass::naudingumo funkcija ( ) ;
}
} ;
tarp pagrindinis ( ) {
MyClass obj;
obj.callUtilityFunction ( ) ;
grąžinti 0 ;
}
Šis kodas apibrėžia dvi klases: „UtilityClass“ ir „MyClass“. „UtilityClass“ turi viešą statinę funkciją, vadinamą „utilityFunction“, kuri konsolėje spausdina „Utility funkcija iškviečiama“. „MyClass“ turi viešą funkciją „callUtilityFunction“, kuri iškviečia „UtilityClass“ funkciją „utilityFunction“.
Pagrindinė funkcija sukuria „MyClass“ objektą, vadinamą „obj“. Tada jis iškviečia objekto „obj“ funkciją „callUtilityFunction“. Dėl to iškviečiama „UtilityClass“ funkcija „utilityFunction“, kuri konsolėje atspausdina „Utility funkcija iškviesta“. Peržiūrėkite šią kodo išvestį:
Šis metodas pašalina atskirų objektų poreikį ir supaprastina kodo struktūrą. Klasėje pateikiami du būdai pasiekti „naudingumo funkciją“. Vienas iš būdų yra tiesiogiai naudoti UtilityClass::utilityFunction() sintaksę, kuri pasiekiama nesukūrus objekto. Kitas būdas yra per objektą, kuris naudoja nario funkciją obj.callUtilityFunction(), kuri suteikia daugiau konteksto ir galimų papildomų funkcijų klasėje. Šis metodas suderina paprastumą ir lankstumą, priklausomai nuo jūsų pageidaujamo naudingumo funkcijos naudojimo modelio.
3 scenarijus: klasės apimtis statiniame visuotiniame kintamajame
Nepriklausomai nuo klasės egzempliorių skaičiaus, narys, kuris klasėje deklaruojamas kaip statinis, egzistuoja tik vienoje kopijoje. Tai taikoma tiek duomenų nariams (kintamiesiems), tiek narių funkcijoms. Svarbu tai, kad statinio duomenų nario apibrėžimas turi būti ne klasės deklaracijoje, paprastai failo srityje.
Štai statikos pavyzdys, kuris taikomas ir duomenų nariui, ir nario funkcijai C++:
#includeklasės skaitiklis {
vieša:
statinis int globalCount;
Skaitliukas ( ) {
++globalCount;
}
statinis tuščias spausdinimasGlobalCount ( ) {
std::cout << „Pasaulinis skaičius yra: << globalCount << std::endl;
}
} ;
int Skaitliukas::globalCount = 0 ;
tarp pagrindinis ( ) {
Skaitliukas skaitiklis1;
Skaitliukas skaitiklis2;
Skaitiklis::printGlobalCount ( ) ;
grąžinti 0 ;
}
Kodas apibrėžia klasę pavadinimu „Counter“ su privačiu statiniu nario kintamuoju pavadinimu „globalCount“ ir dviem viešosiomis nario funkcijomis. Viena iš jų yra Counter (), kuri yra konstruktoriaus funkcija, kuri padidina „globalCount“ kintamąjį. Kitas yra „printGlobalCount“, kuris grąžina dabartinę „globalCount“ kintamojo reikšmę. Kode taip pat yra pagrindinė funkcija. Ši funkcija sukuria du „Counter“ klasės objektus, kurie identifikuojami „counter1“ ir „counter2“ pavadinimais. Po kintamojo deklaracijos ji iškviečia funkciją „Counter::printGlobalCount“, kuri tikriausiai atspausdina dabartinę „globalCount“ kintamojo reikšmę. Žr. šį išvesties fragmentą:
Šiame pavyzdyje „globalCount“ kintamasis deklaruojamas kaip statinis duomenų narys „Counter“ klasėje. Tai reiškia, kad egzistuoja tik viena šio kintamojo kopija, nepaisant to, kiek „Counter“ objektų sukurta. Skaitiklio () konstruktorius padidina kiekvieno egzemplioriaus „globalCount“, parodydamas jo bendrą pobūdį tarp objektų. „printGlobalCount“ yra statinė nario funkcija. Atminkite, kad tai daroma tiesiogiai naudojant klasės pavadinimą (Counter::printGlobalCount). Išvestis rodo, kad „globalCount“ padidinamas, kaip tikėtasi, atspindėdamas bendrą būseną visuose „Counter“ klasės egzemplioriuose.
Išvada
Apibendrinant galima pasakyti, kad statiniai pasauliniai kintamieji C++ pasirodo kaip universalus įrankis funkcijų ir failų būsenai valdyti. Jų vidinis ryšys, nuolatinis pobūdis ir kontroliuojamas dalijimasis informacija daro juos vertingu turtu tam tikruose programavimo scenarijuose. Suprasdami jų ypatybes, tyrinėdami įvairius naudojimo atvejus ir pripažindami galimus spąstus, kūrėjai gali efektyviai valdyti statinius pasaulinius kintamuosius, sustiprinti kodo moduliškumą ir palengvinti ryšį tarp skirtingų savo projektų dalių. Kruopščiai apsvarstant ir laikantis geriausios praktikos, statiniai pasauliniai kintamieji gali būti panaudoti siekiant teigiamai prisidėti prie C++ programų dizaino ir funkcionalumo.