La parola chiave "mutable" ha uno scopo diverso da quello di consentire la modifica della variabile da una funzione const?

Qualche tempo fa mi sono imbattuto in un codice che ha contrassegnato una variabile membro di una classe con la mutableparola chiave. Per quanto posso vedere, ti permette semplicemente di modificare una variabile in un constmetodo:

class Foo  
{  
private:  
    mutable bool done_;  
public:  
    void doSomething() const { ...; done_ = true; }  
};

È questo l'unico uso di questa parola chiave o c'è di più di quello che sembra? Da allora ho usato questa tecnica in una classe, contrassegnando un boost::mutexcome mutabile che consente constalle funzioni di bloccarlo per motivi di sicurezza del thread, ma, a dire il vero, sembra un po 'un trucco.

Permette la differenziazione di const bit per bit e const logica. La const logica è quando un oggetto non cambia in modo visibile attraverso l'interfaccia pubblica, come nel tuo esempio di blocco. Un altro esempio potrebbe essere una classe che calcola un valore la prima volta che viene richiesto e memorizza nella cache il risultato.

Poiché c ++ 11 mutablepuò essere utilizzato su un lambda per indicare che le cose catturate dal valore sono modificabili (non lo sono per impostazione predefinita):

int x = 0;
auto f1 = [=]() mutable {x = 42;};  // OK
auto f2 = [=]()         {x = 42;};  // Error: a by-value capture cannot be modified in a non-mutable lambda

La mutableparola chiave è un modo per perforare il constvelo che drappeggi sui tuoi oggetti. Se hai un riferimento const o un puntatore a un oggetto, non puoi modificarlo in alcun modo tranne quando e come è contrassegnato mutable.

Con il tuo constriferimento o puntatore sei costretto a:

• accesso in sola lettura per tutti i membri di dati visibili
• permesso di chiamare solo i metodi contrassegnati come const.

L' mutableeccezione lo rende così ora puoi scrivere o impostare membri di dati che sono contrassegnati mutable. Questa è l'unica differenza visibile esternamente.

Internamente quei constmetodi che sono visibili a te possono anche scrivere ai membri di dati che sono contrassegnati mutable. In sostanza, il velo const viene perforato in modo completo. Spetta completamente al progettista API assicurarsi che mutablenon distrugga il constconcetto e venga utilizzato solo in casi speciali utili. La mutableparola chiave aiuta perché indica chiaramente i membri dei dati che sono soggetti a questi casi speciali.

In pratica puoi usare constossessivamente tutto il tuo codebase (essenzialmente vuoi "infettare" il tuo codebase con la const"malattia"). In questo mondo, puntatori e riferimenti hanno constpochissime eccezioni, producendo codice che è più facile ragionare e comprendere. Per una digressione interessante cercare "trasparenza referenziale".

Senza la mutableparola chiave alla fine sarai costretto a utilizzare const_castper gestire i vari casi speciali utili che consente (memorizzazione nella cache, conteggio dei riferimenti, dati di debug, ecc.). Sfortunatamente const_castè significativamente più distruttivo che mutableperché costringe il client API a distruggere la constprotezione degli oggetti che sta usando. Inoltre provoca una constdistruzione diffusa : const_castl'inging un puntatore const o riferimento consente la scrittura senza restrizioni e il metodo che chiama l'accesso ai membri visibili. Al contrario, mutableil progettista dell'API deve esercitare un controllo accurato sulle consteccezioni, e di solito queste eccezioni sono nascoste nei constmetodi che operano su dati privati.

(NB Mi riferisco alla visibilità dei dati e del metodo alcune volte. Sto parlando di membri contrassegnati come pubblici o privati ​​o protetti, che è un tipo completamente diverso di protezione degli oggetti discussi qui .)

Il tuo utilizzo con boost :: mutex è esattamente lo scopo di questa parola chiave. Un altro uso è la memorizzazione nella cache dei risultati interna per velocizzare l'accesso.

Fondamentalmente, "mutabile" si applica a qualsiasi attributo di classe che non influisce sullo stato visibile esternamente dell'oggetto.

Nel codice di esempio nella tua domanda, mutable potrebbe essere inappropriato se il valore di done_ influenza lo stato esterno, dipende da cosa c'è nel ...; parte.

Mutabile è per contrassegnare l'attributo specifico come modificabile all'interno dei constmetodi. Questo è il suo unico scopo. Pensa attentamente prima di usarlo, perché il tuo codice sarà probabilmente più pulito e più leggibile se cambi il design piuttosto che usarlo mutable.

http://www.highprogrammer.com/alan/rants/mutable.html

Quindi se la follia di cui sopra non è ciò che è mutevole, a cosa serve? Ecco il caso sottile: mutabile è per il caso in cui un oggetto è logicamente costante, ma in pratica deve cambiare. Questi casi sono pochi e lontani tra loro, ma esistono.

Esempi forniti dall'autore includono la memorizzazione nella cache e variabili di debug temporanee.

È utile in situazioni in cui è stato nascosto lo stato interno come una cache. Per esempio:

classe HashTable
{
...
pubblico:
    ricerca stringhe (chiave stringa) const
    {
        if (key == lastKey)
            return lastValue;

        valore stringa = lookupInternal (chiave);

        lastKey = chiave;
        lastValue = value;

        valore di ritorno;
    }

privato:
    stringa mutabile lastKey, lastValue;
};

E poi puoi avere un const HashTableoggetto che usa ancora il suo lookup()metodo, che modifica la cache interna.

mutable esiste come si deduce per consentire a uno di modificare i dati in una funzione altrimenti costante.

L'intento è che potresti avere una funzione che "non fa nulla" allo stato interno dell'oggetto, quindi contrassegni la funzione const, ma potresti davvero aver bisogno di modificare alcuni stati degli oggetti in modi che non influiscono sul suo corretto funzionalità.

La parola chiave può fungere da suggerimento per il compilatore: un compilatore teorico può inserire un oggetto costante (come un globale) in memoria contrassegnato come di sola lettura. La presenza di mutablesuggerimenti che ciò non dovrebbe essere fatto.

Ecco alcuni motivi validi per dichiarare e utilizzare i dati mutabili:

• Sicurezza del filo. Dichiarare a mutable boost::mutexè perfettamente ragionevole.
• Statistiche. Contando il numero di chiamate a una funzione, dati alcuni o tutti i suoi argomenti.
• Memoizzazione. Calcolare una risposta costosa e quindi memorizzarla per riferimento futuro anziché ricalcolarla di nuovo.

Bene, sì, è quello che fa. Lo uso per i membri che sono modificati da metodi che non cambiano logicamente lo stato di una classe, ad esempio per velocizzare le ricerche implementando una cache:

class CIniWrapper
{
public:
   CIniWrapper(LPCTSTR szIniFile);

   // non-const: logically modifies the state of the object
   void SetValue(LPCTSTR szName, LPCTSTR szValue);

   // const: does not logically change the object
   LPCTSTR GetValue(LPCTSTR szName, LPCTSTR szDefaultValue) const;

   // ...

private:
   // cache, avoids going to disk when a named value is retrieved multiple times
   // does not logically change the public interface, so declared mutable
   // so that it can be used by the const GetValue() method
   mutable std::map<string, string> m_mapNameToValue;
};

Ora, devi usarlo con cura: i problemi di concorrenza sono una grande preoccupazione, poiché un chiamante potrebbe presumere che siano thread-safe se solo usando constmetodi. E, naturalmente, la modifica dei mutabledati non dovrebbe cambiare il comportamento dell'oggetto in alcun modo significativo, qualcosa che potrebbe essere violato dall'esempio che ho fornito se, ad esempio, ci si aspettasse che le modifiche scritte sul disco fossero immediatamente visibili all'app .

Mutabile viene utilizzato quando all'interno della classe è presente una variabile che viene utilizzata solo all'interno di quella classe per segnalare cose come ad esempio un mutex o un lock. Questa variabile non modifica il comportamento della classe, ma è necessaria per implementare la sicurezza dei thread della classe stessa. Quindi se senza "mutable", non saresti in grado di avere funzioni "const" perché questa variabile dovrà essere cambiata in tutte le funzioni che sono disponibili al mondo esterno. Pertanto, è stato introdotto il parametro mutable per rendere scrivibile una variabile membro anche da una funzione const.

Il mutabile specificato informa sia il compilatore che il lettore che è sicuro e previsto che una variabile membro possa essere modificata all'interno di una funzione membro const.

mutable viene utilizzato principalmente su un dettaglio di implementazione della classe. L'utente della classe non ha bisogno di saperlo, quindi secondo lui il metodo "dovrebbe" essere const può essere. Il tuo esempio di avere un mutex mutabile è un buon esempio canonico.

Il tuo uso non è un hack, anche se come molte cose in C ++, mutable può essere un hack per un programmatore pigro che non vuole tornare indietro e contrassegnare qualcosa che non dovrebbe essere const come non-const.

Usa "mutable" quando per cose che sono LOGICALLY apolidi per l'utente (e quindi dovrebbero avere "const" getter nelle API della classe pubblica) ma NON sono apolidi nell'ATTUAZIONE sottostante (il codice nel tuo .cpp).

I casi che uso più frequentemente sono l'inizializzazione lenta di membri "normali dati" senza stato. Vale a dire, è ideale nei casi stretti in cui tali membri sono costosi da costruire (processore) o portare in giro (memoria) e molti utenti dell'oggetto non li chiederanno mai. In quella situazione si desidera una costruzione pigra sul back-end per le prestazioni, poiché il 90% degli oggetti costruiti non avrà mai bisogno di costruirli affatto, tuttavia è ancora necessario presentare l'API stateless corretta per il consumo pubblico.

Mutabile cambia il significato di const da const bit a bit in const logica per la classe.

Ciò significa che le classi con membri mutabili sono più costanti bit a bit e non appariranno più nelle sezioni di sola lettura dell'eseguibile.

Inoltre, modifica il controllo del tipo consentendo constalle funzioni membro di cambiare membri mutabili senza usare const_cast.

class Logical {
    mutable int var;

public:
    Logical(): var(0) {}
    void set(int x) const { var = x; }
};

class Bitwise {
    int var;

public:
    Bitwise(): var(0) {}
    void set(int x) const {
        const_cast<Bitwise*>(this)->var = x;
    }
};

const Logical logical; // Not put in read-only.
const Bitwise bitwise; // Likely put in read-only.

int main(void)
{
    logical.set(5); // Well defined.
    bitwise.set(5); // Undefined.
}

Vedi le altre risposte per maggiori dettagli, ma volevo sottolineare che non è solo per la sicurezza dei tipi e che influenza il risultato compilato.

In alcuni casi (come gli iteratori mal progettati), la classe deve tenere un conto o qualche altro valore accidentale, che non influisce realmente sullo "stato" principale della classe. Questo è molto spesso dove vedo mutevole usato. Senza mutevole, saresti costretto a sacrificare l'intera costanza del tuo design.

Anche a me sembra un hack per la maggior parte del tempo. Utile in pochissime situazioni.

L'esempio classico (come menzionato in altre risposte) e l'unica situazione che ho visto mutable parola chiave utilizzata finora, è per memorizzare nella cache il risultato di un Getmetodo complicato , in cui la cache è implementata come membro di dati della classe e non come variabile statica nel metodo (per motivi di condivisione tra più funzioni o pulizia semplice).

In generale, le alternative all'uso della mutableparola chiave sono generalmente una variabile statica nel metodo o nelconst_cast trucco.

Un'altra spiegazione dettagliata è qui .

Il mutabile può essere utile quando si esegue l'override di una funzione virtuale const e si desidera modificare la variabile membro della classe figlio in quella funzione. Nella maggior parte dei casi non si desidera modificare l'interfaccia della classe di base, quindi è necessario utilizzare la propria variabile membro mutabile.

La parola chiave mutabile è molto utile quando si creano stub a scopo di test di classe. È possibile stub una funzione const ed essere comunque in grado di aumentare i contatori (mutabili) o qualunque funzionalità di test aggiunta al proprio stub. Ciò mantiene intatta l'interfaccia della classe stubbed.

Uno dei migliori esempi in cui usiamo mutable è, in copia profonda. nel costruttore di copie inviamo const &objcome argomento. Quindi il nuovo oggetto creato sarà di tipo costante. Se vogliamo cambiare (per lo più non cambieremo, in rari casi potremmo cambiare) i membri in questo oggetto const appena creato, dobbiamo dichiararlo come mutable.

mutablela classe di archiviazione può essere utilizzata solo su un membro di dati non const non statico di una classe. Il membro di dati mutabili di una classe può essere modificato anche se fa parte di un oggetto dichiarato come const.

class Test
{
public:
    Test(): x(1), y(1) {};
    mutable int x;
    int y;
};

int main()
{
    const Test object;
    object.x = 123;
    //object.y = 123;
    /* 
    * The above line if uncommented, will create compilation error.
    */   

    cout<< "X:"<< object.x << ", Y:" << object.y;
    return 0;
}

Output:-
X:123, Y:1

Nell'esempio sopra, siamo in grado di cambiare il valore della variabile membro xsebbene faccia parte di un oggetto dichiarato come const. Questo perché la variabile xè dichiarata mutabile. Ma se provi a modificare il valore della variabile membro y, il compilatore genererà un errore.

La stessa parola chiave "mutable" è in realtà una parola chiave riservata. Spesso viene utilizzata per variare il valore della variabile costante. Se si desidera avere più valori di un constsnt, utilizzare la parola chiave mutable.

//Prototype 
class tag_name{
                :
                :
                mutable var_name;
                :
                :
               };