【C++ 函数后面加 const 的深度解析】

class MyClass {
public:
    // 常量成员函数
    void display() const; 
    
    // 非常量成员函数
    void modify(); 
};

// 编译器视角的转换
void display(const MyClass* this); // const 版本
void modify(MyClass* this);        // 非 const 版本

class Counter {
    int count; // 普通成员
    mutable int accessCount; // mutable 成员
public:
    void increment() const {
        // count++;       // 错误！不能修改普通成员
        accessCount++;    // 允许：mutable 成员可修改
    }
};

class TextBuffer {
    std::string text;
public:
    // 非 const 版本
    char& operator[](size_t pos) {
        return text[pos]; // 返回可修改引用
    }
    
    // const 版本
    const char& operator[](size_t pos) const {
        return text[pos]; // 返回只读引用
    }
};

// 使用场景
TextBuffer buffer; 
buffer[0] = 'A'; // 调用非 const 版本

const TextBuffer cbuf;
char c = cbuf[0]; // 调用 const 版本
// cbuf[0] = 'B'; // 错误！尝试修改 const 对象

class Person {
    std::string name;
    int age;
public:
    // const Getter：安全访问成员
    std::string getName() const { return name; }
    int getAge() const { return age; }
};

void printPerson(const Person& p) {
    // 可调用 const 方法
    std::cout << p.getName() << ", " << p.getAge();
}

class Shape {
public:
    // 纯虚 const 方法：强制派生类实现常量计算
    virtual double area() const = 0;
};

class Circle : public Shape {
    double radius;
public:
    double area() const override { 
        return 3.14159 * radius * radius; 
    }
};

#include <vector>

void process(const std::vector<int>& vec) {
    // 必须使用 const 版本的 begin/end
    for (auto it = vec.begin(); it != vec.end(); ++it) {
        // *it = 10; // 错误！迭代器是 const_iterator
    }
}

class DataWrapper {
    std::vector<int> data;
public:
    // 非 const 版本调用 const 版本避免重复
    const int& at(size_t pos) const {
        // 复杂边界检查...
        return data[pos];
    }
    
    int& at(size_t pos) {
        // 使用 const_cast 移除常量性
        return const_cast<int&>(
            static_cast<const DataWrapper*>(this)->at(pos)
        );
    }
};

class Cache {
    mutable std::mutex mtx; // 可被 const 方法修改
    mutable std::vector<int> cachedData;
    mutable bool cacheValid = false;
public:
    void updateCache() const {
        std::lock_guard<std::mutex> lock(mtx);
        if (!cacheValid) {
            // 模拟耗时计算
            cachedData = {1, 2, 3, 4, 5};
            cacheValid = true;
        }
    }
};

class Matrix {
    double* data;
    int rows, cols;
public:
    // const 方法返回 const 指针
    const double* rowData(int r) const {
        return data + r * cols;
    }
    
    // 非 const 方法返回普通指针
    double* rowData(int r) {
        return data + r * cols;
    }
};

class A {
    B* b;
public:
    // 正确：返回 const 指针
    const B* getB() const { return b; }
    
    // 错误：返回非 const 指针
    // B* getB() const { return b; } 
};

class Account {
    double balance;
public:
    void deductFee() const {
        balance -= 5.0; // 错误！const 方法不能修改成员
    }
};

class Logger {
    std::vector<std::string> logs;
public:
    void addLog(const std::string& msg) { logs.push_back(msg); }
    
    void printAll() const {
        for (const auto& log : logs) {
            std::cout << log << "\n";
        }
        addLog("Printed"); // 错误！const 方法调用非 const 方法
    }
};

class Config {
    std::map<std::string, std::string> settings;
public:
    // 危险：外部可通过引用修改内部状态
    std::map<std::string, std::string>& getSettings() const {
        return settings; // 错误！返回非 const 引用
    }
};