'mutable'キーワードには、変数をconst関数で変更できるようにする以外の目的がありますか？

しばらく前に、クラスのメンバー変数をmutableキーワードでマークするコードを見つけました。私が見る限り、constメソッド内の変数を変更できます。

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

これがこのキーワードの唯一の使用ですか、それとも見た目以上のものですか？それ以来、クラスでこの手法を使用して、スレッドセーフな理由で関数をロックboost::mutexできるミュータブルとしてマークしましたconstが、正直なところ、少しハックのように感じます。

これにより、ビット単位のconstと論理的なconstを区別できます。論理的なconstは、ロックの例のように、オブジェクトがパブリックインターフェイスから見える方法で変更されない場合です。別の例としては、最初に要求されたときに値を計算し、その結果をキャッシュするクラスがあります。

mutableラムダでc ++ 11 を使用して、値によってキャプチャされたものが変更可能であることを示すことができるため（デフォルトでは変更できません）：

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

mutableキーワードは突き刺すする方法ですconstあなたがオブジェクトの上に羽織るベールを。オブジェクトへのconst参照またはポインタがある場合、いつ、どのようにマークされているかを除いて、そのオブジェクトを変更することはできませんmutable。

あなたとのconst参照やポインタあなたがに制限されています。

• 可視データメンバーの読み取りアクセスのみ
• としてマークされているメソッドのみを呼び出す権限const。

mutableあなたは今、マークされているデータメンバを書いたり、セットすることができますので、例外はそれを作りますmutable。これが、外部から見える唯一の違いです。

内部const的には、表示されているメソッドは、マークされているデータメンバーに書き込むこともできますmutable。基本的に、constベールは包括的にピアスされます。それがコンセプトをmutable破壊しないことを保証するのは完全にAPIデザイナー次第でありconst、有用な特別な場合にのみ使用されます。mutableキーワードは、これらの特別なケースの対象となっていること明確にマークデータメンバために役立ちます。

実際にはconst、コードベース全体にこだわって使用できます（基本的に、コードベースをconst「病気」に「感染」させる必要があります）。この世界では、ポインターと参照にはconstほとんど例外がなく、推論と理解が容易なコードが生成されます。興味深い余談については、「参照透過性」を調べてください。

なけれmutableキーワードあなたは最終的に使用するように強制されますconst_cast、それは（キャッシング、参照カウント、デバッグデータ等）ことができる種々の有用な特殊なケースを処理します。残念ながら、API クライアントが使用しているオブジェクトの保護を強制const_cast的に破壊するmutableため、より破壊的です。さらに、広範囲にわたる破壊を引き起こします。constポインターまたは参照を使用すると、可視メンバーへの自由な書き込みおよびメソッド呼び出しアクセスが可能になります。対照的に、APIデザイナーは例外をきめ細かく制御する必要があり、通常これらの例外はプライベートデータで動作するメソッドに隠されています。constconstconst_castmutableconstconst

（NBはデータとメソッドの可視性を数回参照します。ここで説明するオブジェクト保護のまったく異なるタイプである、パブリックまたはプライベートまたは保護されているとマークされたメンバーについて話しています。）

boost :: mutexでの使用は、まさにこのキーワードの目的です。別の用途は、アクセスを高速化するための内部結果キャッシュです。

基本的に、「可変」は、オブジェクトの外部から見える状態に影響を与えないクラス属性に適用されます。

質問のサンプルコードでは、done_の値が外部の状態に影響を与える場合、mutableは不適切な場合があります。これは...の内容によって異なります。部。

ミュータブルは、特定の属性をconstメソッド内から変更可能としてマークするためのものです。それが唯一の目的です。を使用するのではなく設計を変更した場合、コードはおそらくよりクリーンで読みやすくなるため、使用する前に慎重に検討してくださいmutable。

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

それで、上記の狂気がミュータブルの目的ではない場合、それは何のためですか？ここに微妙なケースがあります：可変はオブジェクトが論理的に一定であるが実際には変更する必要がある場合です。これらのケースはほとんどありませんが、存在しています。

著者の例には、キャッシングや一時的なデバッグ変数が含まれます。

キャッシュなどの内部状態が非表示になっている場合に役立ちます。例えば：

クラスHashTable
{
...
公衆：
    文字列検索（文字列キー）const
    {
        if（key == lastKey）
            lastValueを返します。

        文字列値= lookupInternal（key）;

        lastKey = key;
        lastValue = value;

        戻り値;
    }

民間：
    可変文字列lastKey、lastValue;
};

その後、内部キャッシュを変更するメソッドをconst HashTableオブジェクトに使用させることができますlookup()。

mutable それ以外の場合は一定の関数でデータを変更できるように推測すると、実際に存在します。

その目的は、オブジェクトの内部状態に対して「何もしない」関数がある可能性があるため、その関数constにマークを付けることですが、実際には、その正しい状態に影響を与えない方法で一部のオブジェクトの状態を変更する必要がある場合があります機能性。

キーワードはコンパイラへのヒントとして機能する場合があります-理論上のコンパイラは、読み取り専用とマークされた定数オブジェクト（グローバルなど）をメモリに配置できます。mutableこれを行うべきではないというヒントの存在。

変更可能なデータを宣言して使用する正当な理由は次のとおりです。

• スレッドセーフ。を宣言することmutable boost::mutexは完全に合理的です。
• 統計。引数の一部またはすべてを指定して、関数の呼び出し回数をカウントします。
• メモ化。高価な答えを計算し、それを再計算するのではなく、後で参照できるように保存します。

そうですね、そうです。クラスの状態を論理的に変更しないメソッドによって変更されたメンバーに使用します。たとえば、キャッシュを実装してルックアップを高速化します。

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;
};

ここで、注意してこれを使用する必要があります。呼び出し側はconstメソッドのみを使用する場合はスレッドセーフであると想定する可能性があるため、同時実行性の問題は大きな懸念事項です。そしてもちろん、mutableデータを変更しても、オブジェクトの動作が大幅に変わることはありません。たとえば、ディスクに書き込まれた変更がすぐにアプリに表示されることが予想される場合、私が示した例に違反する可能性があります。 。

ミュータブルは、クラス内でのみ使用される変数がクラス内にある場合に使用されます。この変数は、たとえばミューテックスやロックなどの信号を送るために使用されます。この変数はクラスの動作を変更しませんが、クラス自体のスレッドセーフを実装するために必要です。したがって、「可変」でないと、「const」関数を使用できません。この変数は、外部の世界で使用できるすべての関数で変更する必要があるためです。したがって、メンバー変数をconst関数でも書き込み可能にするために、ミュータブルが導入されました。

指定されたmutableは、安全であり、メンバー変数がconstメンバー関数内で変更される可能性があることを期待して、コンパイラーとリーダーの両方に通知します。

mutableは主にクラスの実装の詳細で使用されます。クラスのユーザーはそれについて知る必要はないので、メソッドはconstであることが「できるはず」であると考えています。mutexを変更可能にする例は、良い標準的な例です。

C ++での多くのことのように、それを使用することはハックではありませんが、変更可能要素は、ずっと前に戻り、constでないものをnon-constとしてマークすることを望まない怠惰なプログラマにとってはハックになる可能性があります。

ユーザーに対して論理的にステートレスである（したがって、パブリッククラスのAPIに「const」ゲッターを含める必要がある）が、基礎となるIMPLEMENTATION（.cppのコード）ではステートレスではない場合は、「可変」を使用します。

私が最も頻繁に使用するケースは、ステートレスな「プレーンな古いデータ」メンバーの遅延初期化です。つまり、そのようなメンバーが構築（プロセッサ）または持ち運び（メモリ）するのに費用がかかり、オブジェクトの多くのユーザーがそれらを要求しないという狭いケースで理想的です。そのような状況では、構築するオブジェクトの90％がオブジェクトをまったく構築する必要がないため、パフォーマンスのためにバックエンドで遅延構築が必要ですが、パブリック消費のために正しいステートレスAPIを提示する必要があります。

Mutable constは、クラスのビット単位のconstからlogical const の意味を変更します。

つまり、可変メンバーを持つクラスはビット単位のconstでなくなり、実行可能ファイルの読み取り専用セクションに表示されなくなります。

さらに、constメンバー関数がを使用せずに可変メンバーを変更できるようにすることで、型チェックを変更し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.
}

詳細については他の回答を参照してください。ただし、これは型安全のためだけのものではなく、コンパイル結果に影響することを強調したいと思います。

（設計が不十分なイテレータのように）場合によっては、クラスはカウントやその他の付随的な値を保持する必要がありますが、これはクラスの主要な「状態」に実際には影響しません。これは、ほとんどの場合、使用されるmutableです。変更可能でないと、設計全体の一貫性を犠牲にしなければなりません。

ほとんどの場合、私にとってもハックのように感じます。ごく一部の状況で役立ちます。

古典的な例（他の回答で述べたとおり）とmutableこれまでに使用したキーワードを見た唯一の状況は、複雑な結果をキャッシュするためのものですGetメソッドので、キャッシュはクラスのデータメンバーとして実装され、クラスのデータメンバーとして実装されませんメソッド内の静的変数（いくつかの関数間での共有または単純な清潔さのため）。

一般に、mutableキーワードを使用する代わりの方法は通常、メソッドまたはconst_castトリックの静的変数です。

別の詳細な説明はここにあります。

mustは、const仮想関数をオーバーライドしていて、その関数の子クラスメンバー変数を変更する場合に便利です。ほとんどの場合、基本クラスのインターフェースを変更したくないので、独自の可変メンバー変数を使用する必要があります。

mutableキーワードは、クラステストの目的でスタブを作成するときに非常に役立ちます。const関数をスタブしても、（可変）カウンターや、スタブに追加したテスト機能を増やすことができます。これにより、スタブ化されたクラスのインターフェースがそのまま維持されます。

mutableを使用する最良の例の1つは、ディープコピーです。コピーコンストラクタではconst &obj、引数として送信します。したがって、作成される新しいオブジェクトは定数型になります。変更したい場合（ほとんど変更しない場合があり、まれに変更する場合があります）、この新しく作成されたconstオブジェクトのメンバーをとして宣言する必要がありますmutable。

mutableストレージクラスは、クラスの非静的非constデータメンバーでのみ使用できます。クラスの可変データメンバーは、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

上記の例ではx、constとして宣言されているオブジェクトの一部ですが、メンバー変数の値を変更できます。これは、変数xが可変として宣言されているためです。しかし、メンバー変数の値を変更しようとするとy、コンパイラーはエラーをスローします。

キーワード 'mutable'は実際には予約済みのキーワードです。多くの場合、定数変数の値を変更するために使用されます。定数の複数の値が必要な場合は、キーワードmutableを使用します。

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