Ho una domanda sulla differenza tra volatile e mutevole. Ho notato che entrambi i due significano che potrebbe essere cambiato. Cos'altro? Sono la stessa cosa? Qual è la differenza? Dove sono applicabili? Perché le due idee vengono proposte? Come usarli in modo diverso?
Molte grazie.
Risposte:
Un mutablecampo può essere modificato anche in un oggetto a cui si accede tramite un constpuntatore o un riferimento, o in un constoggetto, così il compilatore sa di non metterlo nella memoria R / O. Una volatileposizioneèuna posizione che può essere modificata da un codice di cui il compilatore non è a conoscenza (ad esempio alcuni driver a livello di kernel), quindi il compilatore sa di non ottimizzare, ad esempio l'assegnazione del registro di quel valore sotto il presupposto non valido che il valore "non possa avere cambiato "dall'ultima volta che è stato caricato in quel registro. Tipi molto diversi di informazioni fornite al compilatore per bloccare tipi molto diversi di ottimizzazioni non valide.
volatilenon significa solo che l'oggetto può cambiare al di fuori della conoscenza del compilatore, ma significa anche che le scritture sull'oggetto non possono essere eliminate dal compilatore anche se quelle scritture sembrano essere inutili. Ad esempio: x = 1; x = 0; se xè volatile, il compilatore deve emettere entrambe le operazioni di scrittura (che potrebbero essere significative a livello hardware). Tuttavia, per un oggetto non volatile, il compilatore potrebbe scegliere di non preoccuparsi di scrivere 1poiché non viene mai utilizzato.
conste volatile! Non puoi cambiare l'oggetto, ma puoi cambiarlo alle tue spalle.
mutable: La parola chiave mutable sovrascrive qualsiasi istruzione const racchiusa. Un membro mutabile di un oggetto const può essere modificato.
volatile: La parola chiave volatile è un modificatore dipendente dall'implementazione, utilizzato quando si dichiarano le variabili, che impedisce al compilatore di ottimizzarle. Volatile dovrebbe essere usato con variabili il cui valore può cambiare in modi inaspettati (cioè attraverso un interrupt), che potrebbero entrare in conflitto con le ottimizzazioni che il compilatore potrebbe eseguire.
Volatile should be used with variables whose value can change in unexpected waysdovremmo preferirlo usarlo con random?
Non sono decisamente la stessa cosa. Mutable interagisce con const. Se si dispone di un puntatore const, normalmente non è possibile modificare i membri. Mutable fornisce un'eccezione a quella regola.
Volatile, d'altra parte, è totalmente estraneo alle modifiche apportate dal programma. Significa che la memoria potrebbe cambiare per motivi che sfuggono al controllo del compilatore, quindi il compilatore deve leggere o scrivere l'indirizzo di memoria ogni volta e non può memorizzare nella cache il contenuto in un registro.
T, memorizzarlo in un const T*e leggere da esso. Se crei quell'oggetto volatile, la memorizzazione del suo indirizzo in const T*fallirà, anche se non stai mai cercando di scrivere. volatilee le modifiche / modifiche / scritture in memoria dal codice del programma sono completamente ortogonali.
Un modo grezzo ma efficace di pensare la differenza è:
volatilebytes_received, mutablereference_count.
Una variabile contrassegnata mutableconsente di modificarla in un metodo dichiarato const.
Una variabile contrassegnata volatiledice al compilatore che deve leggere / scrivere la variabile ogni volta che anche il tuo codice la dice (cioè non può ottimizzare gli accessi alla variabile).
Vorrei aggiungere che volatile è anche molto utile quando si ha a che fare con applicazioni multithreading, cioè si ha il thread principale (dove risiede main ()) e si genera un thread di lavoro che continuerà a girare mentre una variabile "app_running" è vera. main () controlla se "app_running" è vero o falso, quindi se non aggiungi l'attributo volatile alla dichiarazione di "app_running", se il compilatore ottimizza l'accesso a "app_running" nel codice eseguito dal thread secondario, main ( ) potrebbe cambiare "app_running" in false ma il thread secondario continuerà a funzionare perché il valore è stato memorizzato nella cache. Ho visto lo stesso comportamento usando gcc su Linux e VisualC ++. Un attributo "volatile" inserito nella dichiarazione "app_running" ha risolto il problema. Così,
volatilegli oggetti possono anche essere modificati da processi che non coinvolgono affatto la CPU. Ad esempio, un registro ricevuto dai byte in una periferica di comunicazione può incrementarsi alla ricezione di un byte (e questo può anche attivare un interrupt). Un altro esempio è un registro dei flag di interruzione in sospeso in una periferica.