C++ const关键字和mutable关键字

在C++中，const关键字用于表示常量或不可修改的值。它可以用于变量、指针、函数参数、成员函数等。使用const关键字可以提高代码的安全性和可读性，防止意外修改数据。

1. const变量

声明为const的变量在初始化后不能被修改。

#include <iostream>

int main() {
    const int x = 10;
    // x = 20; // 错误：不能修改const变量

    std::cout << "x: " << x << std::endl;
    return 0;
}

2. const指针

2.1 指针常量（Pointer to Constant）

指针常量是指向常量数据的指针，也就是说，通过这个指针不能修改它所指向的对象的值。指针常量的定义形式是 const type* 或 type const*。

示例代码

#include <iostream>

int main() {
    int value = 10;
    const int* ptr = &value; // 或者 int const* ptr = &value;

    std::cout << "Value: " << *ptr << std::endl;

    // 尝试修改指向的值（会导致编译错误）
    // *ptr = 20; // 错误：不能通过指针常量修改值

    value = 20; // 可以直接修改变量
    std::cout << "Modified Value: " << *ptr << std::endl;

    return 0;
}

2.2 常量指针（Constant Pointer）

常量指针是指针本身是常量，也就是说，这个指针一旦初始化后，就不能再指向其他对象。常量指针的定义形式是type* const。

示例代码

#include <iostream>

int main() {
    int value1 = 10;
    int value2 = 20;
    int* const ptr = &value1;

    std::cout << "Value1: " << *ptr << std::endl;

    // 尝试修改指针本身（会导致编译错误）
    // ptr = &value2; // 错误：不能修改常量指针的指向

    // 可以通过指针修改指向的值
    *ptr = 30;
    std::cout << "Modified Value1: " << *ptr << std::endl;

    return 0;
}

2.3 常量指针常量（Constant Pointer to Constant）

既是指针常量又是常量指针，指针本身和它指向的值都不能被修改，都是常量。定义形式是const type* const 或 type const* const。

示例代码

#include <iostream>

int main() {
    int y = 10;
    const int* const ptr = &y;
    // *ptr = 20; // 错误：不能通过指针修改const值
    // ptr = &z;  // 错误：不能修改const指针的指向

    std::cout << "*ptr: " << *ptr << std::endl;
    return 0;
}

3. const函数参数

3.1 值传递参数

对值传递的参数使用const没有意义，因为函数内部修改的是参数的副本。

void func(int x) {
    // x是值传递的副本
}

3.2 指针参数

指针参数指向的值不应被修改。

void func(const int* ptr) {
    // *ptr = 20; // 错误：不能修改const指针指向的值
}

3.3 引用参数

引用参数的值不应被修改。

void func(const int& ref) {
    // ref = 20; // 错误：不能修改const引用的值
}

4. const成员函数

成员函数声明为const表示该函数不会修改对象的成员变量。

#include <iostream>

class MyClass {
public:
    MyClass(int value) : value(value) {}

    // const成员函数
    int getValue() const {
        // value = 20; // 错误：不能在const成员函数中修改成员变量
        return value;
    }

private:
    int value;
};

int main() {
    MyClass obj(10);
    std::cout << "Value: " << obj.getValue() << std::endl;
    return 0;
}

5. const与mutable

mutable关键字允许在const成员函数中修改特定成员变量。通常用于调试时方便地修改临时变量，如计数等；

#include <iostream>

class MyClass {
public:
    MyClass(int value) : value(value) {}

    int getValue() const {
        okCnt++;
        return value;
    }

    int getOkCnt() const {
        return okCnt;
    }

private:
    int value;
    mutable int okCnt;
};

int main() {
    MyClass obj(10);
    obj.getValue();
    std::cout << "Call success cnt: " << obj.getOkCnt() << std::endl;
    return 0;
}

6. const返回类型

函数返回类型为const可以防止返回值被修改。

#include <iostream>

const int& getValue(const int& x) {
    return x;
}

int main() {
    int y = 10;
    const int& ref = getValue(y);
    // ref = 20; // 错误：不能修改const引用的值

    std::cout << "ref: " << ref << std::endl;
    return 0;
}

总结

• const变量：表示常量，初始化后不能修改。
• const指针：可以限制指针指向的值或指针本身的修改。
• const函数参数：用于指针和引用参数，防止在函数内部修改参数。
• const成员函数：保证函数不会修改对象的成员变量。
• mutable关键字：允许在const成员函数中修改特定成员变量。
• const返回类型：防止返回值被修改。

使用const关键字可以提高代码的安全性和可读性，防止意外修改数据。合理使用const是编写高质量C++代码的重要技巧。