A problémák akkor fordulhatnak elő, ha nem használunk olyan illékony minősítőt, amely magában foglalja, ha az optimalizálás engedélyezve van, előfordulhat, hogy a kód nem működik a várt módon. Ha a megszakításokat használják és engedélyezik, a kód nem működik a tervezett módon. Az adatok csak akkor őrződnek meg az illékony tárolóban, amikor a készülék be van kapcsolva. A kellék eltávolításakor adatvesztés történik.
A nem felejtő tároló azonban akkor is megőrzi az adatokat, ha az áramellátás megszűnik. A folyamatinformációkat rövid ideig az illékony tárolón tárolják, mivel ez lényegesen gyorsabb, mint a nem felejtő tároló. A nem felejtő tárolókkal szemben az illékony tárolás alkalmasabb az érzékeny adatok védelmére. Ennek az az oka, hogy az adatokhoz nem lehet hozzáférni, ha a tápellátás ki van kapcsolva. Az illékony tárhely sokba kerül, mert a számítógépes rendszerek csak néhány MB-tól néhány GB-ig képesek elférni.”
A volatile minősítő tulajdonságai C++ nyelven
Itt bemutatjuk a C++ illékony minősítő átlagát. Amikor deklarálunk egy változót, a „volatile” minősítő kerül alkalmazásra. Emlékeztetőül szolgál a fordító számára, hogy az érték bármikor változhat. Az illékonyak rendelkeznek az alább felsorolt tulajdonságok némelyikével.
• A memória hozzárendelése nem módosítható a volatile kulcsszóval.
• A regiszter változói nem tárolhatók gyorsítótárban.
• A hozzárendelés szempontjából az érték nem módosítható.
A Volatile Qualifier használata C++ nyelven
1. Annak ellenére, hogy a kód nem módosítja a változó értékét, mégis megteheti. Ennek eredményeként a fordító minden alkalommal, amikor ellenőrzi a változó állapotát, nem tudja feltételezni, hogy az megegyezik a belőle kiolvasott legfrissebb vagy a legutóbb tárolt értékkel; hanem még egyszer meg kell szereznie a változó értékét.
2. A fordítónak nem kell megszüntetnie az érték tárolását, mivel ez egy kívülről látható „mellékhatás”, amely akkor lép fel, amikor egy értéket egy változó változóba mentünk. Például, ha két értéket helyezünk el egy sorban, a fordítónak kétszer kell megadnia az értéket.
Az illékony minősítő szintaxisa C++ nyelven
# Az illékony adattípus változó_neveA volatile kulcsszót kell használni a deklarációban, és az adattípus bármilyen adattípusra utal, beleértve a double, float vagy integereket. Végül választunk nevet a változónak. Bármelyik módszerrel definiálhatunk illékony változót, mivel mindkét deklaráció érvényes.
Példa: Az illékony minősítő olyan objektumok azonosítására szolgál, amelyeket más szálak vagy külső műveletek módosíthatnak a C++-ban
Ha az objektumot egy külső jel vagy egy megszakításként működő eljárás megváltoztatja, akkor a megváltozott értéket le kell kérni a RAM-ból, mert a gyorsítótárazott állapot időközben már nem megfelelő. Ennek eredményeként a fordító megfelelően kezeli az illékony objektumokhoz való hozzáférést.
#include#include
#include
std használatával :: cout ;
std használatával :: endl ;
std használatával :: cerr ;
std használatával :: enni ;
illó int másodpercig = 0 ;
üres KésleltetésFiveSeconds ( ) {
míg ( másodpercig < 3 ) {
alszol ( 200 000 ) ;
cerr << 'várakozás...' << endl ;
}
}
üres IncrementSeconds ( ) {
számára ( int én = 0 ; én < 5 ; ++ én ) {
alvás ( 1 ) ;
cerr << 'megnövelt ' << endl ;
másodpercig = másodpercig + 1 ;
}
}
int fő- ( ) {
struct időbeli kezdés { } ;
struct idővége { } ;
std :: cérna szál 1 ;
szál 1 = std :: cérna ( IncrementSeconds ) ;
KésleltetésFiveSeconds ( ) ;
szál 1. csatlakozik ( ) ;
Visszatérés EXIT_SUCCESS ;
}
A lehetséges forgatókönyv szemléltetésére a volatile kulcsszót használtuk, amelynek a változója Seconds adattípusként van deklarálva „int”, és 0 értéket rendeltünk hozzá. Ezután két függvényt készítünk: az egyiket „DelayFiveSeconds”-ként, amely megváltoztatja a globális ingadozó egész változót, a másikat „IncrementSeconds”-ként, amely ugyanazt a kiértékelést hajtja végre a while cikluson belül. Meg kell jegyezni, hogy ez a példa lehetővé teszi, hogy a while ciklus azokon a másodperceken keresztül hurkoljon, amikor a másodpercek 3-nál kisebbek.
Ha a feltétel teljesül, akkor a while blokk végrehajtásra kerül. A while blokkon belül meghívtuk az unsleep metódust, amely kiírja a „waiting” utasítást. Az „IncrementSceonds” függvény for ciklussal rendelkezik. Az iteráció után az alvás metódus hívódik meg, amely kiírja az „increment” utasítást, és növeli a „seconds” változót. Az „IncrementSeconds” funkció kezdeti végrehajtását a fő függvény által létrehozott külön szál végzi. A „DelayFiveSeconds” metódust ezután a főszál hívja meg, és belép egy ciklusba, amely nem ér véget, ha a másodperces változó nem haladja meg az 5 értéket.
Amint a főszál észreveszi, hogy a másodperces változó értéke megváltozott, visszatér a metódusból, mert egy másik szál egyidejűleg már elkezdte növelni.
A szálkód futtatásához C++ nyelven a „g++ -pthread –o fájlnév fájlnév.cc” parancsot kell használnunk. Ha nem telepíti a „-pthread”-et a parancsban, akkor fennáll annak a lehetősége, hogy kivételt dob a fordító. Ennek eredményeként hatékonyan hoztunk létre egy feltételes várakozási függvényt, amely megvárja, amíg az illékony objektumot egy külső erő megváltoztatja. Fontos szem előtt tartani, hogy a frissítési kódblokk származhat egy másik fordítási szakaszból vagy külső jelműveletből, bár ez a kód továbbra is ugyanúgy fog működni, ha az illékony minősítőt eltávolítják, és egy hagyományos globális változót használnak.
Következtetés
Itt áttekintjük a Volatile C++-ban, valamint a szintaxist, a használatot és a megfelelő példákat a jobb megértés érdekében. Mivel a fordító nem tudja megjósolni az értéket, a volatilis kulcsfontosságú a C programozásban. A volatile használatának elsődleges előnye, hogy értéke változhat, amikor egy felhasználó módosítását kéri, vagy ha egy másik, ugyanazt a változót használó szál aktív.