Как изменить состояние константного метода?

Как изменить состояние константного метода

Проблема и решение

Константный метод (помеченный const) обещает не изменять состояние объекта:

class User {
private:
    std::string name_;
    mutable int access_count_;  // ключевое слово mutable
    
public:
    // Константный метод не может менять state через this
    std::string get_name() const {
        // name_ = "John";  // ОШИБКА: нельзя менять неmutable поля
        access_count_++;     // OK: mutable поле можно менять
        return name_;
    }
};

Способ 1: ключевое слово mutable

Это основной и правильный способ.

Что такое mutable:

• Позволяет изменять поле даже в const методах
• Используется для «логически неизменяемых» полей
• Мутабельные поля не входят в логическое состояние объекта

class Cache {
private:
    mutable std::map<std::string, std::string> cache_;
    mutable int hits_ = 0;
    mutable int misses_ = 0;
    
public:
    std::string get(const std::string& key) const {
        if (cache_.find(key) != cache_.end()) {
            hits_++;  // OK: mutable
            return cache_[key];
        }
        misses_++;  // OK: mutable
        return "";
    }
};

Примеры использования mutable:

1. Кэширование:

class Calculator {
private:
    mutable int cached_result_;
    mutable bool cache_valid_ = false;
    
public:
    int compute() const {
        if (cache_valid_) {
            return cached_result_;
        }
        cached_result_ = expensive_calculation();
        cache_valid_ = true;
        return cached_result_;
    }
};

1. Счётчики и статистика:

class Database {
private:
    mutable int query_count_ = 0;
    mutable int total_time_ms_ = 0;
    
public:
    std::vector<Record> query(const std::string& sql) const {
        auto start = std::chrono::now();
        // ... выполнить запрос
        query_count_++;
        total_time_ms_ += duration;
        return results;
    }
};

1. Логирование:

class Sensor {
private:
    mutable std::vector<std::string> logs_;
    
public:
    int read_value() const {
        logs_.push_back("read called");
        return value_;
    }
};

Способ 2: const_cast (НЕ рекомендуется)

Можно принудительно снять const, но это опасно:

class BadExample {
private:
    int value_ = 0;
    
public:
    void modify() const {
        const_cast<BadExample*>(this)->value_++;
    }
};

Почему это плохо:

• Нарушает контракт const
• Может привести к undefined behavior если объект реально const
• Сложнее отлаживать
• Нарушает принцип наименьших привилегий

const int CONST_VALUE = 10;
int* ptr = const_cast<int*>(&CONST_VALUE);
*ptr = 20;  // UNDEFINED BEHAVIOR на некоторых платформах!
// Компилятор может оптимизировать CONST_VALUE
// и прочитать старое значение из памяти

Способ 3: внешнее состояние

Передать mutable объект как параметр:

class Logger {
public:
    void log(const std::string& msg, std::vector<std::string>& logs) const {
        logs.push_back(msg);
    }
};

int main() {
    Logger logger;
    std::vector<std::string> logs;
    logger.log("Start", logs);
}

Когда использовать каждый способ

mutable — выбор правильный:

• Кэширование результатов вычислений
• Счётчики и метрики (访问了多少раз, сколько запросов)
• Логирование при неизменяемом интерфейсе
• Лениво инициализируемые поля

class Matrix {
private:
    std::vector<double> data_;
    mutable double norm_ = -1;  // -1 = не вычислено
    
public:
    double get_norm() const {
        if (norm_ < 0) {
            norm_ = compute_norm();
        }
        return norm_;
    }
};

const_cast — только в крайних случаях:

• Интеграция со старым C-кодом
• Третьесторонние библиотеки, которые неправильно аннотированы const
• Крайне редко в новом коде

// Пример: интеграция с C API
void c_function(int* ptr);  // Не помечена const, но не меняет данные

class Wrapper {
private:
    int value_;
    
public:
    void process() const {
        // Приходится использовать const_cast
        // потому что C API некорректно аннотирована
        c_function(const_cast<int*>(&value_));
    }
};

Практический пример: наилучшие практики

class ThreadPool {
private:
    std::vector<std::thread> threads_;
    mutable std::mutex stats_mutex_;
    mutable int tasks_processed_ = 0;
    mutable int errors_count_ = 0;
    
public:
    // const метод — не меняет основное состояние
    TaskResult execute_task(const Task& task) const {
        {
            std::lock_guard<std::mutex> lock(stats_mutex_);
            tasks_processed_++;
        }
        
        try {
            return process(task);
        } catch (const std::exception& e) {
            std::lock_guard<std::mutex> lock(stats_mutex_);
            errors_count_++;
            throw;
        }
    }
    
    // Получение статистики из const метода
    int get_tasks_processed() const {
        std::lock_guard<std::mutex> lock(stats_mutex_);
        return tasks_processed_;
    }
};

Итоговые рекомендации

✅ Используй mutable для:

• Кэширования и ленивой инициализации
• Сбора статистики и метрик
• Оптимизации производительности

❌ Избегай const_cast в новом коде

• Нарушает контракт const
• Может привести к UB
• Затрудняет отладку

✅ Правильная const-семантика:

• Логически неизменяемое поле → mutable
• Действительное изменение состояния → non-const метод
• Внешнее состояние → передай как параметр