I problemi potrebbero verificarsi se non utilizziamo un qualificatore volatile che include, quando l'ottimizzazione è abilitata, il codice potrebbe non funzionare come previsto. Quando gli interrupt vengono utilizzati e abilitati, il codice non può funzionare come pianificato. I dati vengono conservati nella memoria volatile solo quando l'alimentazione è accesa. Quando la fornitura viene rimossa, si verifica una perdita di dati.
Tuttavia, l'archiviazione non volatile conserva i dati anche in caso di interruzione dell'alimentazione. Le informazioni di processo vengono archiviate brevemente su una memoria volatile poiché è notevolmente più veloce della memoria non volatile. A differenza dello storage non volatile, lo storage volatile è più adatto a salvaguardare i dati sensibili. Questo perché i dati sono inaccessibili quando l'alimentazione è interrotta. Lo storage volatile costa molto perché i sistemi informatici possono ospitare solo da pochi MB a pochi GB'.
Proprietà del qualificatore volatile in C++
I mezzi del qualificatore volatile C++ verranno illustrati qui. Quando dichiariamo una variabile, viene applicato il qualificatore 'volatile'. Serve a ricordare al compilatore che il valore può variare in qualsiasi momento. Il volatile possiede alcuni dei tratti elencati di seguito.
• L'assegnazione della memoria non può essere modificata con la parola chiave volatile.
• Le variabili del registro non possono essere memorizzate nella cache.
• In termini di assegnazione, il valore non è modificabile.
Utilizzo del qualificatore volatile in C++
1. Nonostante il tuo codice non modifichi il valore della variabile, potrebbe comunque farlo. Di conseguenza, ogni volta che il compilatore controlla lo stato della variabile, non può presumere che sia uguale al valore più recente letto da essa o al valore più recente memorizzato; anzi, deve acquisire nuovamente il valore della variabile.
2. Al compilatore non è richiesto di eliminare l'atto di memorizzare un valore poiché è un 'effetto collaterale' che può essere visto dall'esterno e si verifica quando un valore viene salvato in una variabile volatile. Ad esempio, se due valori vengono inseriti in una riga, il compilatore deve inserire il valore due volte.
Sintassi del qualificatore volatile in C++
# Tipo_dati volatili nome_variabileLa parola chiave volatile deve essere utilizzata nella dichiarazione e il tipo di dati fa riferimento a qualsiasi tipo di dati, inclusi double, float o intero. Infine, scegliamo un nome per la variabile. Possiamo definire una variabile volatile usando uno dei metodi poiché entrambe le dichiarazioni sono valide.
Esempio: il qualificatore volatile viene utilizzato per identificare oggetti che possono essere modificati da altri thread o azioni esterne in C++
Se l'oggetto viene modificato da un segnale esterno o da una procedura che funge da interrupt, il valore alterato deve essere recuperato dalla RAM perché lo stato memorizzato nella cache non è più appropriato nel frattempo. Di conseguenza, il compilatore gestisce l'accesso agli oggetti volatili in modo appropriato.
#includi#include
#includi
usando std :: cout ;
usando std :: fine ;
usando std :: cerr ;
usando std :: mangiare ;
volatile int secondi = 0 ;
vuoto DelayFiveSeconds ( ) {
mentre ( secondi < 3 ) {
dormi ( 200000 ) ;
cerr << 'in attesa...' << fine ;
}
}
vuoto Incrementa secondi ( ) {
per ( int io = 0 ; io < 5 ; ++ io ) {
dormire ( 1 ) ;
cerr << 'incrementato' << fine ;
secondi = secondi + 1 ;
}
}
int principale ( ) {
struttura inizio temporale { } ;
struttura fine temporale { } ;
std :: filo filo1 ;
filo1 = std :: filo ( Incrementa secondi ) ;
DelayFiveSeconds ( ) ;
filo1. giuntura ( ) ;
Restituzione EXIT_SUCCESS ;
}
Per illustrare lo scenario potenziale, abbiamo utilizzato la parola chiave volatile che ha la variabile dichiarata come Secondi di tipo di dati 'int' e le è stato assegnato un valore pari a 0. Quindi, costruiamo due funzioni: una come 'DelayFiveSeconds' che altera la variabile intera volatile globale e un'altra come 'IncrementSeconds' che esegue la stessa valutazione all'interno del ciclo while. Va notato che questo esempio consente al ciclo while di essere ripetuto sui secondi quando i secondi dovrebbero essere inferiori a 3.
Quando la condizione soddisfa, verrà eseguito il blocco while. All'interno del blocco while, abbiamo invocato il metodo unsleep che stampa l'istruzione 'waiting'. La funzione 'IncrementSceonds' ha il ciclo for. Dopo l'iterazione, viene invocato il metodo sleep, che stampa l'istruzione 'increment' e incrementa la variabile 'seconds'. L'esecuzione iniziale della funzione 'IncrementSeconds' viene eseguita da un thread separato creato dalla funzione principale. Il metodo 'DelayFiveSeconds' viene quindi chiamato dal thread principale, inserendo un ciclo che non terminerà se la variabile secondi non si sposta sopra il valore di 5.
Non appena il thread principale nota che il valore della variabile secondi è cambiato, tornerà dal metodo perché un altro thread ha già iniziato ad aumentarlo contemporaneamente.
Per eseguire il codice del thread in C++, dovremmo usare il comando “g++ -pthread –o filename filename.cc”. Se non si distribuisce '-pthread' nel comando, è possibile che venga generata un'eccezione dal compilatore. Di conseguenza, abbiamo effettivamente creato una funzione di attesa condizionale che attende fino a quando l'oggetto volatile non viene modificato da una forza esterna. È importante tenere presente che il blocco del codice di aggiornamento potrebbe provenire da una sezione di traduzione diversa o da un'azione del segnale esterno, anche se questo codice funzionerà comunque allo stesso modo se il qualificatore volatile viene rimosso e viene utilizzata una variabile globale convenzionale.
Conclusione
Qui, esaminiamo una panoramica di Volatile in C++ insieme alla sintassi, all'utilizzo e agli esempi appropriati per una migliore comprensione. Poiché il compilatore non può prevedere il valore, volatile è fondamentale nella programmazione C. Il vantaggio principale dell'utilizzo di volatile è che il suo valore può variare ogni volta che un utente ne richiede la modifica o quando è attivo qualche altro thread che utilizza la stessa variabile.