【C++】mutableの使い方を徹底解説！const関数やラムダ式での活用例

2026年3月1日

C++においてconst修飾子は、オブジェクトの状態を変更しないことを保証するための非常に重要な機能です。

しかし、プログラムを設計していると、オブジェクトの「論理的な状態」は変わらないものの、「内部的な実装上の都合」で一部の変数を書き換えたい場面に遭遇します。

このような矛盾を解決するために用意されているのがmutableキーワードです。

本記事では、mutableの基本的な役割から、キャッシュ処理やスレッドセーフな設計における活用、さらにはラムダ式での特殊な挙動まで、具体的なサンプルコードを交えて詳しく解説します。

目次 [ close ]

mutableの基本的な役割と概念

C++のmutableは、メンバ変数に対して指定することで、その変数がconstメンバ関数内からでも変更可能であることを明示するキーワードです。

通常、constがついたメンバ関数内では、オブジェクトの全てのメンバ変数は読み取り専用となりますが、mutableを付与することでこの制限を「個別に」解除できます。

物理的定数性と論理的定数性の違い

mutableを理解する上で欠かせないのが、「物理的定数性(Bitwise Constness)」と「論理的定数性(Logical Constness)」の考え方です。

物理的定数性とは、メモリ上のビットが1つも変わらないことを指します。

C++のデフォルトのconstはこの立場を取ります。

一方で論理的定数性とは、「外部から見たオブジェクトの状態が変わっていなければ、内部的に何かが書き換わっても良い」という考え方です。

例えば、関数の実行回数をカウントするデバッグ用の変数や、計算結果を一時的に保存しておくキャッシュ用変数は、オブジェクトの「価値」そのものには影響しません。

このような変数を扱う際にmutableが活躍します。

基本的な構文と動作確認

まずは、mutableを使用しない場合に発生するエラーと、使用した場合の挙動をコードで確認してみましょう。

C++

#include <iostream>

class Counter {
private:
    // mutableを付与することで、const関数内でも変更可能になる
    mutable int access_count = 0;
    int data = 100;

public:
    // constメンバ関数
    int getData() const {
        // data = 200; // これはコンパイルエラーになる
        
        // mutableな変数は変更可能
        access_count++; 
        return data;
    }

    int getAccessCount() const {
        return access_count;
    }
};

int main() {
    const Counter c;
    std::cout << "Data: " << c.getData() << std::endl;
    std::cout << "Data: " << c.getData() << std::endl;
    std::cout << "Access Count: " << c.getAccessCount() << std::endl;
    return 0;
}

実行結果

Data: 100
Data: 100
Access Count: 2

この例では、getData()はオブジェクトの状態を外部に返すだけのconst関数ですが、内部で「何回呼ばれたか」を記録するためにaccess_countを更新しています。

mutableがあるおかげで、オブジェクトをconstとして扱いつつ、統計情報だけを更新することが可能になっています。

キャッシュ(メモイゼーション)での活用例

実務で最もmutableが重宝されるケースの一つが、計算コストの高い処理の結果をキャッシュする仕組みの実装です。

計算結果を保持する仕組み

例えば、複雑な数式計算やデータベースからの取得結果を返すメンバ関数があるとします。

これらは論理的には「取得」操作なのでconstであるべきですが、パフォーマンスのために初回計算結果をメンバ変数に保存しておきたい場合があります。

C++

#include <iostream>
#include <vector>

class ExpensiveCalculator {
private:
    // 計算結果が有効かどうかを保持
    mutable bool is_cached = false;
    // 計算結果を保持するキャッシュ
    mutable double cached_value = 0.0;

    // 実際の大変な計算（シミュレーション）
    double performHeavyCalculation() const {
        std::cout << "Performing expensive calculation..." << std::endl;
        return 42.0 * 1.2345;
    }

public:
    // const関数だが、内部でキャッシュを更新する
    double getValue() const {
        if (!is_cached) {
            cached_value = performHeavyCalculation();
            is_cached = true;
        }
        return cached_value;
    }
};

int main() {
    ExpensiveCalculator calc;

    // 初回：計算が実行される
    std::cout << "First call: " << calc.getValue() << std::endl;

    // 2回目：キャッシュされた値が返される
    std::cout << "Second call: " << calc.getValue() << std::endl;

    return 0;
}

実行結果

Performing expensive calculation...
First call: 51.849
Second call: 51.849

このコードにおいて、getValue()を利用する側は、内部でキャッシュが行われているかどうかを気にする必要はありません。

このようにカプセル化を維持しながら最適化を図るために、mutableは非常に有用です。

スレッドセーフな設計とmutable

マルチスレッド環境において、constメンバ関数が必ずしもスレッドセーフであるとは限りません。

しかし、現代的なC++設計指針では「constはスレッドセーフであるべき」という考え方が一般的です。

ここで、排他制御のためのstd::mutexをメンバ変数として持つ場合、mutableが必須となります。

ミューテックスをmutableにする理由

std::mutexのlock()やunlock()は、ミューテックス自身の内部状態を書き換えます。

そのため、constメンバ関数内でロックを取得しようとすると、ミューテックスがmutableでない限りコンパイルエラーが発生します。

C++

#include <iostream>
#include <mutex>
#include <string>

class ThreadSafeBaggage {
private:
    std::string content;
    // mutexは内部状態が変わるため、mutableにする必要がある
    mutable std::mutex mtx;

public:
    void setContent(const std::string& s) {
        std::lock_guard<std::mutex> lock(mtx);
        content = s;
    }

    // const関数内でもロックをかけるためにmutableが必要
    std::string getContent() const {
        std::lock_guard<std::mutex> lock(mtx);
        return content;
    }
};

int main() {
    ThreadSafeBaggage bag;
    bag.setContent("Secret Document");
    
    std::cout << "Content: " << bag.getContent() << std::endl;
    return 0;
}

実行結果

Content: Secret Document

ミューテックスはオブジェクトのデータそのものではなく、「データへのアクセスを制御するための道具」に過ぎません。

したがって、これをmutableにすることは論理的定数性の観点からも正当化されます。

ラムダ式におけるmutableキーワード

C++11から導入されたラムダ式においても、mutableキーワードは特別な意味を持ちます。

通常、値キャプチャされた変数はラムダ式の内部（operator()）ではconstとして扱われ、変更することができません。

値キャプチャした変数の書き換え

ラムダ式にmutableを付けると、値キャプチャしたコピーに対して変更を加えることが可能になります。

C++

#include <iostream>

int main() {
    int counter = 0;

    // mutableがないと、内部でcounter++はできない
    auto incrementer = [counter]() mutable {
        counter++; // コピーされたcounterを更新
        std::cout << "Inside lambda: " << counter << std::endl;
    };

    incrementer();
    incrementer();
    incrementer();

    // 元の変数は影響を受けない（値キャプチャなので）
    std::cout << "Outside lambda: " << counter << std::endl;

    return 0;
}

実行結果

Inside lambda: 1
Inside lambda: 2
Inside lambda: 3
Outside lambda: 0

ここで注意が必要なのは、このcounterは元のmain関数にある変数ではなく、ラムダ式オブジェクトが内部に保持しているコピーであるという点です。

mutableを付与することで、ラムダ式を「状態を持つ関数オブジェクト」として振る舞わせることができます。

mutableを使用する際の注意点と設計指針

mutableは便利な道具ですが、多用するとプログラムの予測可能性を損なう恐れがあります。

適切に使用するための指針をまとめます。

項目	推奨されるケース	避けるべきケース
用途	キャッシュ、統計、同期(Mutex)	主要なビジネスロジックの状態変更
透明性	外部から見て状態変化が分からない	外部の期待を裏切る副作用がある
設計	論理的定数性を維持するため	constの制約を回避するためだけの場当たり的な使用

乱用の危険性

mutableを「constをつけるのが面倒だから、あるいはコンパイルエラーを消したいから」という理由で使用してはいけません。

メンバ変数がmutableであるということは、その変数がいつ、どのconst関数から書き換わってもおかしくないことを意味します。

これはデバッグの難易度を上げ、コードの可読性を低下させる原因になります。

あくまで「オブジェクトの外部的な振る舞いや意味的な状態」を保護しつつ、内部実装を最適化するための手段として限定的に利用するのがベストプラクティスです。

まとめ

C++におけるmutableは、「論理的な不変性」を保ちつつ「物理的な柔軟性」を確保するための強力なキーワードです。

主な活用シーンは以下の通りです：

constメンバ関数内でのキャッシュ（メモイゼーション）の実装。
マルチスレッド対応のためのstd::mutexの操作。
ラムダ式で値キャプチャした変数の状態更新。

これらを適切に使い分けることで、型の安全性を高めるconstの恩恵を受けながらも、パフォーマンスや機能性を犠牲にしない洗練された設計が可能になります。

正しく理解して、保守性の高いC++コードを目指しましょう。