De problemen kunnen optreden als we geen vluchtige kwalificatie gebruiken die inhoudt dat wanneer optimalisatie is ingeschakeld, de code mogelijk niet werkt zoals verwacht. Wanneer interrupts worden gebruikt en ingeschakeld, kan de code niet werken zoals gepland. Gegevens worden alleen bewaard in vluchtige opslag terwijl de stroom is ingeschakeld. Wanneer de voeding wordt verwijderd, treedt gegevensverlies op.
Niet-vluchtige opslag bewaart echter gegevens, zelfs als de stroom uitvalt. Procesinformatie wordt kort opgeslagen op vluchtige opslag, aangezien dit aanzienlijk sneller is dan niet-vluchtige opslag. In tegenstelling tot niet-vluchtige opslag, is vluchtige opslag meer geschikt om gevoelige gegevens te beschermen. Dit komt omdat de gegevens niet toegankelijk zijn wanneer de voeding is uitgeschakeld. Vluchtige opslag kost veel omdat computersystemen maar een paar MB tot een paar GB kunnen bevatten.”
Eigenschappen van de vluchtige kwalificatie in C++
De vluchtige kwalificatiemiddelen van C++ zullen hier worden gedemonstreerd. Wanneer we een variabele declareren, wordt de kwalificatie 'vluchtig' toegepast. Het dient als een herinnering aan de compiler dat de waarde op elk moment kan variëren. De vluchtige hebben enkele van de onderstaande eigenschappen.
• De geheugentoewijzing kan niet worden gewijzigd met het vluchtige trefwoord.
• De variabelen van het register kunnen niet in de cache worden opgeslagen.
• Qua toewijzing kan de waarde niet worden gewijzigd.
Gebruik van de vluchtige kwalificatie in C++
1. Ondanks dat uw code de waarde van de variabele niet wijzigt, kan dit toch gebeuren. Dientengevolge kan de compiler elke keer dat de toestand van de variabele wordt gecontroleerd, niet aannemen dat deze dezelfde is als de meest recente waarde die ervan is gelezen of de meest recente waarde die is opgeslagen; in plaats daarvan moet het de waarde van de variabele opnieuw verwerven.
2. De compiler hoeft de handeling van het opslaan van een waarde niet te elimineren, aangezien dit een 'neveneffect' is dat van buitenaf kan worden gezien en optreedt wanneer een waarde wordt opgeslagen in een vluchtige variabele. Als er bijvoorbeeld twee waarden op een rij worden geplaatst, moet de compiler de waarde twee keer invoeren.
Syntaxis van de vluchtige kwalificatie in C++
# Vluchtige data_type variabele_naamHet vluchtige sleutelwoord moet in de declaratie worden gebruikt en het gegevenstype verwijst naar elk gegevenstype, inclusief double, float of integer. Ten slotte kiezen we een naam voor de variabele. We kunnen een vluchtige variabele definiëren met behulp van een van de methoden, aangezien beide declaraties geldig zijn.
Voorbeeld: de vluchtige kwalificatie wordt gebruikt om objecten te identificeren die kunnen worden gewijzigd door andere threads of externe acties in C ++
Als het object wordt gewijzigd door een extern signaal of een procedure die als een interrupt fungeert, moet de gewijzigde waarde uit het RAM worden opgehaald omdat de cachestatus in de tussentijd niet langer geschikt is. Als gevolg hiervan behandelt de compiler de toegang tot vluchtige objecten op de juiste manier.
#include#include
#include
met behulp van std :: cout ;
met behulp van std :: eindel ;
met behulp van std :: zeker ;
met behulp van std :: aan het eten ;
vluchtig int seconden = 0 ;
leegte VertragingVijfSeconden ( ) {
terwijl ( seconden < 3 ) {
jij slaapt ( 200000 ) ;
zeker << 'aan het wachten...' << eindel ;
}
}
leegte IncrementSeconden ( ) {
voor ( int i = 0 ; i < 5 ; ++ i ) {
slaap ( 1 ) ;
zeker << 'verhoogd' << eindel ;
seconden = seconden + 1 ;
}
}
int hoofd ( ) {
structureren tijdsbegin { } ;
structureren einde van de tijd { } ;
soa :: draad draad1 ;
draad1 = soa :: draad ( IncrementSeconden ) ;
VertragingVijfSeconden ( ) ;
draad1. meedoen ( ) ;
opbrengst EXIT_SUCCESS ;
}
Om het mogelijke scenario te illustreren, hebben we het vluchtige sleutelwoord gebruikt waarvan de variabele is gedeclareerd als Seconden van het gegevenstype 'int' en er een waarde van 0 aan toegewezen. Vervolgens construeren we twee functies: een als 'DelayFiveSeconds' die de globale vluchtige integer-variabele wijzigt, en een andere als 'IncrementSeconds' die dezelfde evaluatie uitvoert in de while-lus. Opgemerkt moet worden dat dit voorbeeld het mogelijk maakt dat de while-lus over de seconden loopt terwijl de seconden kleiner dan 3 zouden moeten zijn.
Wanneer aan de voorwaarde wordt voldaan, wordt het while-blok uitgevoerd. Binnen het while-blok hebben we de unsleep-methode aangeroepen die de instructie 'wachten' afdrukt. De functie 'IncrementSceonds' heeft de for-lus. Na de iteratie wordt de slaapmethode aangeroepen, die de instructie 'increment' afdrukt en de variabele 'seconds' verhoogt. De eerste uitvoering van de functie 'IncrementSeconds' wordt gedaan door een aparte thread die door de hoofdfunctie is gemaakt. De methode 'DelayFiveSeconds' wordt vervolgens aangeroepen door de hoofdthread, waardoor een lus wordt ingevoerd die niet zal eindigen als de secondevariabele niet boven de waarde van 5 komt.
Zodra de hoofdthread merkt dat de waarde van de secondenvariabele is gewijzigd, keert deze terug van de methode omdat een andere thread deze al gelijktijdig is gaan verhogen.
Om de threadcode in C++ uit te voeren, moeten we het commando 'g++ -pthread –o bestandsnaam bestandsnaam.cc' gebruiken. Als u de '-pthread' in de opdracht niet implementeert, bestaat de kans dat er een uitzondering wordt gegenereerd door de compiler. Als resultaat hebben we effectief een voorwaardelijke wachtfunctie gemaakt die wacht tot het vluchtige object wordt veranderd door een kracht van buitenaf. Het is belangrijk om in gedachten te houden dat het updatecodeblok afkomstig kan zijn van een andere vertaalsectie of externe signaalactie, ook al zal deze code nog steeds hetzelfde functioneren als de vluchtige kwalificatie wordt verwijderd en een conventionele globale variabele wordt gebruikt.
Conclusie
Hier bespreken we een overzicht van Vluchtig in C++ samen met de syntaxis, het gebruik en geschikte voorbeelden voor een beter begrip. Omdat de compiler de waarde niet kan voorspellen, is vluchtig van cruciaal belang in C-programmering. Het belangrijkste voordeel van het gebruik van vluchtig is dat de waarde ervan kan variëren wanneer een gebruiker vraagt om deze te wijzigen of wanneer een andere thread actief is die dezelfde variabele gebruikt.