Что такое mutable объект?

Mutable объект в C++

Mutable объект — это объект, состояние которого может изменяться после создания. Это противоположность immutable (неизменяемых) объектов. В C++ это ключевой концепт для понимания правильного дизайна классов и управления состоянием.

Определение

Mutable объект — объект, значения данных-членов которого могут быть изменены после инициализации.

Immutable объект — объект, значения данных-членов которого не могут быть изменены после инициализации.

// ========================================
// MUTABLE объект — можно изменять
// ========================================
class MutableUser {
public:
  void setName(std::string name) {
    this->name = name;  // МОЖНО изменять
  }
  void setAge(int age) {
    this->age = age;    // МОЖНО изменять
  }
private:
  std::string name;
  int age;
};

MutableUser user("Alice", 30);
user.setName("Bob");  // Состояние меняется
user.setAge(25);      // Состояние меняется

// ========================================
// IMMUTABLE объект — нельзя изменять
// ========================================
class ImmutableUser {
public:
  ImmutableUser(std::string name, int age) : name(name), age(age) {}
  
  std::string getName() const { return name; }  // Только читать
  int getAge() const { return age; }             // Только читать
  
  // НЕТ сеттеров — нельзя изменять
private:
  const std::string name;  // Константные поля
  const int age;
};

ImmutableUser user("Alice", 30);
// user.setName("Bob");  // ОШИБКА КОМПИЛЯЦИИ — нет метода

Ключевое слово mutable

В C++ есть специальное ключевое слово mutable, которое позволяет изменять поле даже в const контексте:

class CacheUser {
private:
  std::string name;
  std::string email;
  mutable std::string cached_display_name;  // Может меняться в const методах
  mutable bool cache_valid = false;
  
public:
  std::string getDisplayName() const {
    if (!cache_valid) {
      // Пересчитываем кэш, хотя метод const
      cached_display_name = name + " <" + email + ">";
      cache_valid = true;
    }
    return cached_display_name;
  }
};

const CacheUser user("Alice", "alice@example.com");
std::cout << user.getDisplayName();  // OK: можем вызвать const метод
// Внутри метода изменяется cached_display_name благодаря mutable

Примеры mutable объектов в практике

1. Простой mutable объект

class Rectangle {
private:
  double width;
  double height;
public:
  Rectangle(double w, double h) : width(w), height(h) {}
  
  void setWidth(double w) { width = w; }      // Меняет состояние
  void setHeight(double h) { height = h; }    // Меняет состояние
  
  double area() const { return width * height; }
};

Rectangle rect(5.0, 10.0);
rect.setWidth(7.0);   // Состояние объекта меняется
rect.setHeight(12.0); // Состояние объекта меняется
std::cout << rect.area();  // 84.0

2. Примеры с кэшированием

class ExpensiveComputation {
private:
  int value;
  mutable int cached_result;
  mutable bool cache_computed = false;
  
public:
  explicit ExpensiveComputation(int v) : value(v) {}
  
  // Const метод, но изменяет mutable члены
  int getSquared() const {
    if (!cache_computed) {
      cached_result = value * value;
      cache_computed = true;
    }
    return cached_result;
  }
};

const ExpensiveComputation comp(5);
std::cout << comp.getSquared();  // 25
std::cout << comp.getSquared();  // 25 (из кэша, не пересчитываем)

3. Счётчик обращений (mutable)

class DatabaseQuery {
private:
  std::string query_string;
  mutable int access_count = 0;
  
public:
  explicit DatabaseQuery(std::string q) : query_string(q) {}
  
  std::string execute() const {
    access_count++;  // Увеличиваем счётчик даже в const методе
    // Выполняем запрос...
    return "result";
  }
  
  int getAccessCount() const { return access_count; }
};

const DatabaseQuery query("SELECT * FROM users");
query.execute();  // access_count = 1
query.execute();  // access_count = 2
std::cout << query.getAccessCount();  // 2

Mutable vs Immutable в контексте const

class DataHolder {
private:
  std::string data;
  mutable std::vector<int> computed_stats;  // Кэш
  mutable bool stats_valid = false;
  
public:
  // const метод изменяет состояние через mutable
  const std::vector<int>& getStats() const {
    if (!stats_valid) {
      computed_stats = computeExpensiveStats();
      stats_valid = true;
    }
    return computed_stats;
  }
  
private:
  std::vector<int> computeExpensiveStats() const {
    // Дорогое вычисление
    return {1, 2, 3, 4, 5};
  }
};

// Использование
const DataHolder holder;  // const объект
auto stats = holder.getStats();  // Работает, хотя вызов const
// getStats() изменит computed_stats благодаря mutable

Mutable объекты: плюсы и минусы

Преимущества mutable объектов

1. Гибкость — можно менять состояние в любой момент
2. Удобство — сеттеры, обновления данных
3. Эффективность — в памяти хранится одна копия

Недостатки mutable объектов

1. Сложность отладки — состояние может измениться неожиданно
2. Проблемы многопоточности — конкурирующие потоки могут конфликтовать
3. Трудность тестирования — нужно следить за всеми состояниями
4. Меньше предсказуемости — объект может быть в разных состояниях

Mutable vs Immutable в многопоточности

// ❌ ОПАСНО: Mutable объект в многопоточном коде
class Counter {  // Mutable
private:
  int value = 0;
public:
  void increment() { value++; }  // RACE CONDITION!
  int getValue() const { return value; }
};

Counter counter;
std::thread t1([&]{ counter.increment(); });  // Один поток
std::thread t2([&]{ counter.increment(); });  // Другой поток
// Ошибка: value может быть 1 вместо 2!

// ✅ БЕЗОПАСНО: Immutable объект
class ImmutableCounter {
private:
  const int value;
public:
  explicit ImmutableCounter(int v) : value(v) {}
  int getValue() const { return value; }  // Только чтение
};

const ImmutableCounter counter(0);
// Безопасно в многопоточности — состояние не меняется

Когда использовать mutable ключевое слово

// ✅ Правильное использование: кэширование/логирование
class UserRepository {
private:
  Database& db;
  mutable std::unordered_map<int, User> cache;
  
public:
  const User& getUser(int id) const {
    if (cache.count(id)) return cache[id];
    
    User user = db.find(id);  // Реальный запрос
    cache[id] = user;         // Кэшируем (mutable)
    return cache[id];
  }
};

// ✅ Правильное использование: счётчики и метрики
class MetricsCollector {
private:
  mutable int call_count = 0;
  mutable long total_time_ms = 0;
  
public:
  void recordCall(int duration_ms) const {
    call_count++;
    total_time_ms += duration_ms;
  }
  
  double getAverageTime() const {
    return total_time_ms / static_cast<double>(call_count);
  }
};

// ❌ НЕПРАВИЛЬНОЕ использование: основное состояние
class WrongDesign {  // НЕ ДО
private:
  mutable int state = 0;  // Плохая идея!
public:
  void updateState() const {
    state = 42;  // Концептуально неправильно
  }
};

Правило большого пальца

• Используйте mutable только для кэширования, логирования, счётчиков — деталей реализации, а не основного состояния
• Основное состояние объекта должно быть иммутабельным в const методах
• В многопоточности предпочитайте immutable объекты
• При необходимости изменяемости используйте обычные (non-const) методы

Mutable — это мощный инструмент, но его нужно использовать с осторожностью и по назначению.