Что означает const в конце объявления функции-члена класса в C++?

Что такое const-квалификация методов?

Ключевое слово const в конце объявления функции-члена называется const-квалификацией (const qualifier) или const-методом. Оно говорит компилятору: "Эта функция обещает не изменять состояние объекта, для которого она вызвана". Другими словами, внутри такого метода вы не можете изменять ни один член класса (кроме тех, что помечены mutable).

Зачем это нужно?

• Контроль доступа: Если у вас есть const-объект (например, объявленный как const MyClass obj), вы можете вызывать только const-методы этого объекта. Обычные методы будут недоступны.
• Самодокументирование: Читая код, вы сразу видите, какие методы безопасны и не изменяют объект. Это упрощает отладку и рефакторинг.
• Оптимизация: Компилятор может лучше оптимизировать код, зная, что объект не будет изменён.

Пример с const-объектом

class Counter {
public:
    Counter() : count(0) {}
    int getCount() const { return count; }  // const-метод
    void increment() { count++; }           // не const
private:
    int count;
};

int main() {
    const Counter constCounter;  // Константный объект
    int val = constCounter.getCount(); // ОК: getCount() — const
    // constCounter.increment();       // Ошибка! increment() — не const

    Counter nonConstCounter;     // Обычный объект
    nonConstCounter.increment(); // ОК
    int val2 = nonConstCounter.getCount(); // ОК
}

Почему increment() не может быть const?

Вернёмся к вашему примеру:

void increment() const { count++; } // Ошибка!

Исключение: mutable

Иногда нужно, чтобы член класса можно было изменять даже в const-методах (например, для кэширования или счётчиков вызовов). Для этого используется ключевое слово mutable:

class CacheExample {
public:
    int getValue() const {
        if (!cached) {
            // Даже в const-методе можно изменить mutable-члены
            cachedValue = expensiveCalculation(); 
            cached = true;
        }
        return cachedValue;
    }
private:
    mutable bool cached = false;
    mutable int cachedValue = 0;
    
    int expensiveCalculation() const { /* ... */ }
};

Перегрузка по const

Вы можете иметь две версии одного метода — const и не-const. Компилятор вызовет нужную в зависимости от того, является ли объект константным:

class MyArray {
public:
    int& operator[](size_t index) {
        return data[index]; // Для не-const объектов
    }
    const int& operator[](size_t index) const {
        return data[index]; // Для const-объектов
    }
private:
    int data[100];
};

Правила использования

• Всегда помечайте const методы, которые логически не должны изменять объект (геттеры, проверки, вычисления).
• Не помечайте const методы, которые изменяют состояние (сеттеры, модификаторы).
• Помните про mutable для редких исключений.

Теперь вы знаете, что const в конце — это мощный инструмент для написания безопасного, читаемого и эффективного кода. Используйте его!

class Logger {
public:
    void log(const std::string& msg) const {
        // Только чтение, не меняем состояние
        std::cout << "[" << timestamp << "] " << msg << std::endl;
    }
    void setTimestamp(const std::string& ts) {
        timestamp = ts; // Меняем состояние
    }
private:
    std::string timestamp;
};