Flygtig C++

Flygtig C



'Udviklere af brugerrumsapplikationer bør altid henvise til de relevante compilermanualer for at lære, hvordan kvalifikationen kan håndteres i forskellige sammenhænge, ​​fordi den flygtige nøgleordsadfærd normalt skal ses som hardwareafhængig. Når et objekt er markeret som flygtigt, informeres compileren ofte om, at det aldrig bør optimeres til indlæsningsoperationer og altid skal hentes fra primær hukommelse i stedet for registre eller caches. Men når compileren forsøger at indsætte hukommelsesplaceringen i registret, bliver den automatisk cachelagret, selvom der er adskillige lag af caches, der stort set ikke er tilgængelige for software og kun vedligeholdes i hardwaren. Som et resultat kan RAM tilgås mange gange hurtigere fra cache-linjer nær CPU'en end fra den identiske hukommelsesplacering.

Problemerne kan opstå, hvis vi ikke bruger en flygtig kvalifikation, der inkluderer, når optimering er aktiveret, koden muligvis ikke fungerer som forventet. Når interrupts er brugt og aktiveret, kan koden ikke fungere som planlagt. Data opbevares kun i flygtigt lager, mens strømmen er tændt. Når forsyningen fjernes, sker der datatab.

Ikke-flygtigt lager opbevarer dog data, selvom strømmen går. Procesinformation lagres kortvarigt på flygtigt lager, da det er betydeligt hurtigere end ikke-flygtigt lager. I modsætning til ikke-flygtig lagring er flygtig lagring mere velegnet til at beskytte følsomme data. Dette skyldes, at dataene er utilgængelige, når strømforsyningen er afbrudt. Flygtig lagerplads koster meget, fordi computersystemer kun kan rumme et par MB til et par GB af det.'







Egenskaber for Volatile Qualifier i C++

C++ flygtige kvalifikationsmidler vil blive demonstreret her. Når vi erklærer en variabel, anvendes kvalifikationen 'flygtig'. Det tjener som en påmindelse til compileren om, at værdien kan variere til enhver tid. De flygtige har nogle af de egenskaber, der er angivet nedenfor.



• Hukommelsestildelingen kan ikke ændres med det flygtige nøgleord.



• Registerets variabler kan ikke cachelagres.





• Tildelingsmæssigt kan værdien ikke ændres.

Brug af Volatile Qualifier i C++

1. Selvom din kode ikke ændrer variablens værdi, kan den ikke desto mindre gøre det. Som et resultat, hver gang compileren kontrollerer variablens tilstand, kan den ikke antage, at den er den samme som den seneste værdi, der er læst fra den, eller den senest gemte værdi; det skal snarere erhverve værdien af ​​variablen igen.



2. Compileren er ikke forpligtet til at eliminere handlingen med at lagre en værdi, da det er en 'bivirkning', der kan ses udefra og opstår, når en værdi gemmes i en flygtig variabel. For eksempel, hvis to værdier er placeret i en række, skal compileren sætte værdien to gange.

Syntaks for Volatile Qualifier i C++

# Flygtig datatype variabel_navn

Det flygtige nøgleord skal bruges i erklæringen, og datatype refererer til enhver datatype, herunder dobbelt, float eller heltal. Til sidst vælger vi et navn til variablen. Vi kan definere en flygtig variabel ved at bruge en af ​​metoderne, da begge erklæringer er gyldige.

Eksempel: Den flygtige kvalificerer bruges til at identificere objekter, der kan ændres af andre tråde eller eksterne handlinger i C++

Hvis objektet ændres af et eksternt signal eller en procedure, der fungerer som en afbrydelse, skal den ændrede værdi hentes fra RAM'en, fordi den cachelagrede tilstand ikke længere er passende i mellemtiden. Som et resultat håndterer compileren adgang til flygtige objekter på passende vis.

#include
#include
#inkluder

bruger std :: cout ;
bruger std :: endl ;
bruger std :: cerr ;
bruger std :: spise ;

flygtige int sekunder = 0 ;

ugyldig DelayFiveSeconds ( ) {
mens ( sekunder < 3 ) {
søvn ( 200.000 ) ;
cerr << 'venter...' << endl ;
}
}

ugyldig Forøg sekunder ( ) {
til ( int jeg = 0 ; jeg < 5 ; ++ jeg ) {
søvn ( 1 ) ;
cerr << 'inkrementeret' << endl ;
sekunder = sekunder + 1 ;
}
}

int vigtigste ( ) {
struktur tidsmæssig start { } ;
struktur tidsmæssig afslutning { } ;
std :: tråd tråd 1 ;

tråd 1 = std :: tråd ( Forøg sekunder ) ;

DelayFiveSeconds ( ) ;

tråd 1. tilslutte ( ) ;
Vend tilbage EXIT_SUCCESS ;
}


For at illustrere det potentielle scenarie har vi brugt det flygtige nøgleord, der har variablen erklæret som sekunder af datatypen 'int' og tildelt en værdi på 0 til det. Derefter konstruerer vi to funktioner: en som 'DelayFiveSeconds', der ændrer den globale flygtige heltalsvariabel, og en anden som 'IncrementSeconds', der udfører den samme evaluering inde i while-løkken. Det skal bemærkes, at dette eksempel tillader, at while-løkken har sløjfet over sekunderne, når sekunderne skal være mindre end 3.

Når betingelsen opfylder, vil while-blokken blive udført. Inde i while-blokken har vi påberåbt sig unsleep-metoden, der udskriver erklæringen 'waiting'. Funktionen 'IncrementSceonds' har for-løkken. Efter iterationen påkaldes sleep-metoden, som udskriver sætningen 'increment' og øger 'seconds'-variablen. Indledende udførelse af 'IncrementSeconds'-funktionen udføres af en separat tråd, der er oprettet af hovedfunktionen. Metoden 'DelayFiveSeconds' kaldes derefter af hovedtråden, der går ind i en løkke, der ikke slutter, hvis sekundvariablen ikke bevæger sig over værdien 5.

Så snart hovedtråden bemærker, at sekundvariablens værdi er ændret, vender den tilbage fra metoden, fordi en anden tråd allerede er begyndt at øge den samtidig.

For at køre trådkoden i C++, skal vi bruge kommandoen 'g++ -pthread -o filnavn filnavn.cc'. Hvis du ikke implementerer '-pthread' i kommandoen, så er der en chance for, at en undtagelse bliver kastet af compileren. Som et resultat lavede vi effektivt en betinget ventefunktion, der venter, indtil det flygtige objekt ændres af en ydre kraft. Det er vigtigt at huske på, at opdateringskodeblokken kan komme fra en anden oversættelsessektion eller ekstern signalhandling, selvom denne kode stadig vil fungere på samme måde, hvis den flygtige qualifier fjernes, og en konventionel global variabel anvendes.

Konklusion

Her gennemgår vi en oversigt over Volatile i C++ sammen med syntaks, brug og passende eksempler for en bedre forståelse. Da compileren ikke kan forudsige værdien, er volatile afgørende i C-programmering. Den primære fordel ved at bruge volatile er, at dens værdi kan variere, når en bruger anmoder om, at den skal ændres, eller når en anden tråd, der bruger den samme variabel, er aktiv.