class DataProcessor {
private:
    mutable std::string cachedResult; // 緩存計算結(jié)果
    mutable bool isCacheValid = false; // 緩存有效性標(biāo)志
    std::vector<int> rawData;
public:
    const std::string& getResult() const {
        if (!isCacheValid) {
            // 在 const 函數(shù)中更新緩存
            cachedResult = computeResult();
            isCacheValid = true;
        }
        return cachedResult;
    }
    void updateData(const std::vector<int>& newData) {
        rawData = newData;
        isCacheValid = false; // 數(shù)據(jù)更新后緩存失效
    }
private:
    std::string computeResult() const { /* 復(fù)雜計算 */ }
};

class ThreadSafeContainer {
private:
    mutable std::mutex mtx; // 互斥鎖
    std::vector<int> data;
public:
    void add(int value) {
        std::lock_guard<std::mutex> lock(mtx);
        data.push_back(value);
    }
    bool contains(int value) const {
        std::lock_guard<std::mutex> lock(mtx); // const 函數(shù)中鎖定
        return std::find(data.begin(), data.end(), value) != data.end();
    }
};

class Sensor {
private:
    mutable int readCount = 0; // 記錄讀取次數(shù)（調(diào)試用）
    double currentValue;
public:
    double readValue() const {
        readCount++; // 不影響傳感器數(shù)據(jù)邏輯狀態(tài)
        return currentValue;
    }
    int getReadCount() const { return readCount; }
};

// 錯誤示例：mutable 破壞了邏輯常量性
class BankAccount {
private:
    mutable double balance; // 危險！
public:
    double getBalance() const {
        balance -= 1.0; // 錯誤！const 函數(shù)不應(yīng)改變賬戶余額
        return balance;
    }
};

class NetworkConnection {
private:
    mutable std::atomic<bool> isConnected_{false}; // 明確標(biāo)記可變狀態(tài)
    // ... 其他成員 ...
};

class Cache {
private:
    mutable std::shared_mutex cacheMutex;
    mutable std::unordered_map<int, std::string> cache;
public:
    std::string get(int key) const {
        std::shared_lock lock(cacheMutex); // 讀鎖（共享）
        if (auto it = cache.find(key); it != cache.end()) {
            return it->second;
        }
        return "";
    }
    void update(int key, const std::string& value) {
        std::unique_lock lock(cacheMutex); // 寫鎖（獨(dú)占）
        cache[key] = value;
    }
};

class ConfigManager {
private:
    mutable std::once_flag initFlag; // 僅用于延遲初始化
    mutable std::string configPath;
    void loadConfig() const {
        std::call_once(initFlag, [this] {
            configPath = readConfigFile(); // 延遲初始化
        });
    }
public:
    const std::string& getConfigPath() const {
        loadConfig(); // 首次調(diào)用時初始化
        return configPath;
    }
};