const的正确姿势：从变量、函数到成员函数

const int bufferSize = 1024; // 值不能修改
bufferSize = 2048; // 错误：表达式必须是可修改的左值

const std::string name = "Alice"; // 对象本身不能修改

    const int* ptr; // ptr 是一个指针，它指向一个 const int
    int const* ptr; // 等价的写法，同样是指向 const int 的指针

    int value = 10;
    const int const_value = 20;

    ptr = &value;    // 正确：允许将非常量地址赋给指向常量的指针（承诺不会通过ptr修改value）
    ptr = &const_value; // 正确

    *ptr = 30; // 错误：不能通过 ptr 修改它所指的值
    value = 30; // 正确：因为 value 本身不是 const

    int* const const_ptr = &value; // const_ptr 是一个const指针，它指向一个 int

    *const_ptr = 40; // 正确：可以修改所指的值
    const_ptr = &const_value; // 错误：不能修改 const_ptr 本身的值（即地址）

    const int* const const_ptr_to_const = &const_value;

    *const_ptr_to_const = 50; // 错误
    const_ptr_to_const = &value; // 错误

void badFunction(std::string& str); // 这个函数承诺会修改 str
std::string myString = "Hello";
const std::string myConstString = "World";

badFunction(myString);      // 正确
badFunction(myConstString); // 错误！不能将 const 引用绑定到非 const 引用参数上

void goodFunction(const std::string& str); // 这个函数承诺不会修改 str

goodFunction(myString);      // 正确：非常量可以转换为常量
goodFunction(myConstString); // 正确
// 两个调用都适用，函数是通用的。

class Fraction { ... };
const Fraction operator*(const Fraction& lhs, const Fraction& rhs);

Fraction a, b, c;
...
(a * b) = c; // 如果没有顶层的const，这句代码是合法的但无意义的！
             // 有了const返回值，这行代码会报错，阻止了这种无意义的操作。

class TextBlock {
public:
    // const 成员函数
    std::size_t length() const {
        return text.length();
    }

    // 非 const 成员函数
    void append(const std::string& extra) {
        text += extra;
    }

private:
    std::string text;
};

// 使用
const TextBlock ctb("Hello");
TextBlock tb("World");

std::cout << ctb.length(); // 正确：const 对象可以调用 const 成员函数
ctb.append("!");           // 错误：const 对象不能调用非 const 成员函数

std::cout << tb.length();  // 正确：非 const 对象可以调用 const 成员函数
tb.append("!");            // 正确

class CTextBlock {
public:
    // 这是一个 bitwise const 函数，但它合适吗？
    const char& operator[](std::size_t position) const {
        return pText[position];
    }

    // 非 const 版本
    char& operator[](std::size_t position) {
        return pText[position];
    }

    // 一个逻辑上应该是 const 的函数，但需要修改缓存长度
    std::size_t getLength() const {
        if (!lengthIsValid) {
            textLength = std::strlen(pText); // 错误！不能在 const 成员函数内修改成员
            lengthIsValid = true;            // 错误！
        }
        return textLength;
    }

private:
    char* pText;
    std::size_t textLength;     // 上一次计算的文本长度
    bool lengthIsValid;         // 当前长度是否有效
};

class CTextBlock {
public:
    std::size_t getLength() const {
        if (!lengthIsValid) {
            textLength = std::strlen(pText); // 现在正确了：mutable 成员可以在 const 成员函数中被修改
            lengthIsValid = true;
        }
        return textLength;
    }

private:
    char* pText;
    mutable std::size_t textLength;   // 使用 mutable
    mutable bool lengthIsValid;       // 使用 mutable
};

class TextBlock {
public:
    const char& operator[](std::size_t position) const { // 一如既往
        // ... 边界检查、日志记录等 ...
        return text[position];
    }

    char& operator[](std::size_t position) {
        // 使用 static_cast 将 *this 转为 const TextBlock&，以调用 const 版本
        // 然后使用 const_cast 移除返回值的 const 属性
        return const_cast<char&>(
            static_cast<const TextBlock&>(*this)[position]
        );
    }
};

const int size = 100; // 运行时常量（也可能被优化为编译期常量）
constexpr int compileTimeSize = 100; // 绝对是编译时常量

std::array<int, size> arr1;        // 可能可行，取决于编译器
std::array<int, compileTimeSize> arr2; // 绝对可行

// constexpr 函数：如果传入编译期常量，它将在编译期计算出结果
constexpr int square(int x) { return x * x; }
int array[square(5)]; // 创建一个大小为 25 的数组，计算在编译期完成

int runtime_val = 10;
int array2[square(runtime_val)]; // 错误！runtime_val 不是编译期常量，square无法在编译期计算。