Volatile C ++
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 previsto. I dati vengono trattenuti solo in memoria volatile mentre l'alimentazione è accesa. Quando la fornitura viene rimossa, si verifica la perdita di dati.
Tuttavia, l'archiviazione non volatile mantiene i dati anche se l'alimentazione si spegne. Le informazioni sul processo sono brevemente memorizzate su una memoria volatile poiché è considerevolmente più veloce della memoria non volatile. A differenza della memoria non volatile, l'archiviazione volatile è più adatta per salvaguardare i dati sensibili. Questo perché i dati sono inaccessibili quando l'alimentazione viene spento. L'archiviazione volatile costa molto perché i sistemi informatici possono ospitare solo pochi MB a pochi GB."
Proprietà del qualificatore volatile in C++
La qualificazione volatile C ++ sarà dimostrata qui. Quando dichiariamo una variabile, viene applicata la qualifica "volatile". Serve come promemoria al compilatore che il valore è tenuto a variare in qualsiasi momento. I volatili possiedono 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 può essere modificato.
Uso 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 lo stesso del valore più recente lettura da esso o del valore più recente memorizzato; Piuttosto, deve acquisire ancora una volta il valore della variabile.
2. Il compilatore non è tenuto a eliminare l'atto di immagazzinare 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 posizionati in una riga, il compilatore deve mettere il valore due volte.
Sintassi del qualificatore volatile in c++
# Volatile data_type variabile_nameLa parola chiave volatile deve essere utilizzata nella dichiarazione e il tipo di dati si riferisce a qualsiasi tipo di dati, inclusi doppio, galleggiante 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 a oggetti volatili in modo appropriato.
#includere#includere
#includere
usando std :: cout;
usando std :: endl;
usando std :: cerr;
usando std :: cin;
volatile int seconds = 0;
void delayFiveSeconds ()
mentre (secondi < 3)
Usleep (200000);
Cerr<< "waiting… " <
void incrementEconds ()
per (int i = 0; i< 5; ++i)
sonno (1);
Cerr<< "incremented " <
int main ()
struct timeval start ;
struct timeval end ;
std :: thread thread1;
thread1 = std :: thread (incrementconds);
DelayFiveSeconds ();
Discussione1.giuntura();
restituire exit_success;
Per illustrare il potenziale scenario, abbiamo utilizzato la parola chiave volatile che ha la variabile dichiarata come secondi di tipo di dati "int" e assegnato un valore di 0 ad esso. Quindi, costruiamo due funzioni: una come "delayfivesconds" che altera la variabile intera volatile globale, e un altro come "incredi" che esegue la stessa valutazione all'interno del ciclo while. Va notato che questo esempio permette al ciclo while di essere aumentato nei secondi in cui i secondi dovrebbero essere inferiori a 3.
Quando la condizione si incontra, verrà eseguito il blocco while. All'interno del blocco, abbiamo invocato il metodo unlep che stampa l'affermazione "in attesa". La funzione "Incrementceonds" ha il loop per. Dopo l'iterazione, viene invocato il metodo del sonno, che stampa l'istruzione "incremento" e incrementa la variabile "secondi". L'esecuzione iniziale della funzione "IncrementEconds" viene eseguita da un thread separato creato dalla funzione principale. Il metodo "DelayFiveSeconds" viene quindi chiamato dal thread principale, inserendo un ciclo che non finirà se la variabile dei secondi non si sposta al di sopra del valore di 5.
Non appena il thread principale nota il valore della variabile secondi è cambiato, tornerà dal metodo perché un altro thread ha già iniziato ad aumentarlo contemporaneamente.
Per eseguire il codice thread in C ++, dovremmo usare il comando “G ++ -pThread -o fileName file file.CC ". Se non si distribuisce il "-pThread" nel comando, allora c'è una possibilità che un'eccezione venga lanciata dal compilatore. Di conseguenza, abbiamo effettivamente realizzato 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 dall'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'uso e agli esempi appropriati per una migliore comprensione. Poiché il compilatore non può prevedere il valore, volatile è cruciale nella programmazione C. Il vantaggio principale dell'utilizzo di volatile è che il suo valore può variare ogni volta che un utente lo richiede da modificare o quando è attivo qualche altro thread che utilizza la stessa variabile.