const关键字

在C++中，const关键字用于声明常量、保护变量不被修改、限制函数行为等。它是用于提升代码安全性和可维护性的一个重要特性。以下是const关键字在不同场景中的使用方式及其作用：

1. 定义常量

const关键字可以用来定义不可修改的常量。在这种情况下，常量的值在初始化时被设置，并且不能在后续的代码中改变。

示例：

const int MAX_SIZE = 100;  // MAX_SIZE 是一个常量，不能被修改

int main() {
    // MAX_SIZE = 200;  // 错误！常量不能修改
    std::cout << "Max size is: " << MAX_SIZE << std::endl;
    return 0;
}

用途：

• 提供一个具名的常量，使代码更具可读性。
• 防止意外修改常量值，增加安全性。

2. 指针和const

在指针和const的组合中，const可以用来保护指针指向的值，或者保护指针本身，甚至两者都可以受保护。

（1）指向常量的指针

指针指向的值是常量，不能通过该指针修改它指向的值。

const int val = 10;
const int* ptr = &val;  // ptr 是一个指向 const int 的指针

// *ptr = 20;  // 错误！不能通过 ptr 修改 val 的值

（2）常量指针

指针本身是常量，不能指向其他地址，但可以修改指针指向的值。

int val1 = 10;
int val2 = 20;
int* const ptr = &val1;  // ptr 是一个常量指针，不能改变指向

*ptr = 30;  // 可以修改 val1 的值
// ptr = &val2;  // 错误！ptr 不能改变指向

（3）指向常量的常量指针

指针和它指向的值都是常量，既不能改变指针指向的值，也不能改变指针本身。

const int val = 10;
const int* const ptr = &val;  // 指针和它指向的值都是常量

// *ptr = 20;  // 错误！不能修改指针指向的值
// ptr = &val2;  // 错误！不能修改指针本身

3. 常量引用

使用const关键字可以创建一个常量引用。常量引用在函数参数传递中非常常见，用于防止函数修改传入的对象，并且避免对象的拷贝。

示例：

void print(const std::string& str) {
    std::cout << str << std::endl;
    // str += " added";  // 错误！不能修改 const 引用的值
}

int main() {
    std::string message = "Hello, World!";
    print(message);
    return 0;
}

用途：

• 通过引用传递对象，避免拷贝的开销。
• 使用const保证函数不会修改传入的参数。

4. 常量成员函数

在类中，const关键字可以用来修饰成员函数，表示该函数不会修改类的成员变量。常量成员函数只能调用其他常量成员函数。

示例：

class MyClass {
private:
    int value;
public:
    MyClass(int v) : value(v) {}

    int getValue() const {  // 常量成员函数
        return value;
    }

    void setValue(int v) {
        value = v;
    }
};

int main() {
    MyClass obj(10);
    std::cout << obj.getValue() << std::endl;  // 常量函数可以调用
    obj.setValue(20);  // 可以修改值
    return 0;
}

在常量成员函数中，编译器会确保函数不会修改任何非mutable的成员变量，从而保证对象的状态不变。

5. 常量对象

通过const关键字，可以创建一个常量对象，表示该对象的所有成员变量和成员函数都不能修改（除非函数是mutable的或是常量成员函数）。

示例：

class MyClass {
private:
    int value;
public:
    MyClass(int v) : value(v) {}

    int getValue() const {
        return value;
    }

    void setValue(int v) {
        value = v;
    }
};

int main() {
    const MyClass obj(10);  // 常量对象
    std::cout << obj.getValue() << std::endl;  // 可以调用常量成员函数
    // obj.setValue(20);  // 错误！不能调用非常量成员函数
    return 0;
}

用途：

• 确保对象在其生命周期中不被修改。
• 只能调用对象的常量成员函数，从而保证数据的安全性。

6. 常量数组

可以用const关键字定义常量数组，数组中的元素值不能被修改。

示例：

const int arr[] = {1, 2, 3, 4, 5};  // 常量数组

int main() {
    // arr[0] = 10;  // 错误！不能修改常量数组的值
    for (int i = 0; i < 5; ++i) {
        std::cout << arr[i] << std::endl;
    }
    return 0;
}

总结

• 定义常量：const int MAX = 10; 确保常量不被修改。
• 常量指针：int* const ptr; 限制指针的修改。
• 指向常量的指针：const int* ptr; 防止通过指针修改值。
• 常量引用：const std::string& ref; 用于引用传递，保证不修改值。
• 常量成员函数：int getValue() const; 防止修改类的成员变量。

使用const可以提升代码的可读性和安全性，防止意外的修改，同时也增强了代码的健壮性和可维护性。