C++基础——const关键字

在C++中，const 关键字是保证代码安全性和可维护性的重要工具。它不仅用于定义常量，还能限制变量和函数的修改行为，是实现高质量C++代码的基石。

const基本概念

常量定义

1const int MAX_SIZE = 100;  // 定义常量，不可修改
2MAX_SIZE = 200;  // ❌ 编译错误，不能修改const变量

相比于传统的宏定义（#define），使用const具有以下优势：

类型安全：编译器会进行类型检查
支持作用域：可以限制常量的可见范围
调试友好：可以在调试器中查看具体值

指针与const

在C++中，const和指针的组合非常灵活，需要特别注意其语义：

语法	含义	示例
`const int* p`	指向常量的指针（指针可变，指向的值不可变）	`p = &b;` ✅ `*p = 20;` ❌
`int* const p`	常量指针（指针不可变，指向的值可变）	`p = &b;` ❌ `*p = 20;` ✅
`const int* const p`	指向常量的常量指针（指针和值都不可变）	`p = &b;` ❌ `*p = 20;` ❌
实际应用示例：

 1int a = 10, b = 20;
 2
 3// 场景1：保护数据不被修改
 4const int* p1 = &a;
 5*p1 = 30;  // ❌ 编译错误
 6p1 = &b;   // ✅ 允许改变指向
 7
 8// 场景2：固定指针指向
 9int* const p2 = &a;
10*p2 = 30;  // ✅ 允许修改值
11p2 = &b;   // ❌ 编译错误
12
13// 场景3：最严格的限制
14const int* const p3 = &a;
15*p3 = 30;  // ❌ 编译错误
16p3 = &b;   // ❌ 编译错误

const在函数中的应用

参数保护

 1// 推荐写法：避免不必要的拷贝，同时保护数据
 2void printUser(const string& name) {
 3    cout << "用户名：" << name << endl;
 4    // name[0] = 'X';  // ❌ 编译错误，防止意外修改
 5}
 6
 7// 不推荐：参数会被拷贝
 8void printUser(string name) {
 9    cout << "用户名：" << name << endl;
10}

成员函数限制

 1class User {
 2public:
 3    // const成员函数：承诺不会修改对象状态
 4    string getName() const {
 5        return name;
 6    }
 7    
 8    // 非const成员函数：可能会修改对象状态
 9    void setName(const string& newName) {
10        name = newName;
11    }
12    
13private:
14    string name;
15};
16
17// 使用示例
18const User user;
19cout << user.getName();     // ✅ 允许
20user.setName("张三");      // ❌ 编译错误

返回值保护

 1class Configuration {
 2public:
 3    // 防止配置被意外修改
 4    const string& getApiKey() const {
 5        return apiKey;
 6    }
 7    
 8private:
 9    string apiKey;
10};

const在类中的应用

常量成员

 1class MathConstants {
 2public:
 3    // 类内初始化（C++11及以后）
 4    const double PI = 3.14159;
 5    
 6    // 构造函数初始化列表（传统方式）
 7    MathConstants() : E(2.71828) {}
 8    
 9private:
10    const double E;  // 必须在构造函数初始化列表中初始化
11};

对象不可变性

 1class ImmutablePoint {
 2public:
 3    ImmutablePoint(int x, int y) : x_(x), y_(y) {}
 4    
 5    // 所有访问方法都是const
 6    int getX() const { return x_; }
 7    int getY() const { return y_; }
 8    
 9private:
10    const int x_;
11    const int y_;
12};

特殊情况：mutable关键字

有时我们需要在const成员函数中修改某些成员变量，这时可以使用mutable：

 1class Cache {
 2public:
 3    int getValue() const {
 4        if (!cached) {
 5            cached = true;           // 允许修改mutable成员
 6            cachedValue = compute(); // 允许修改mutable成员
 7        }
 8        return cachedValue;
 9    }
10    
11private:
12    mutable bool cached = false;
13    mutable int cachedValue = 0;
14    
15    int compute() const {
16        // 复杂计算...
17        return 42;
18    }
19};

性能优化与const

编译器优化

1const int BUFFER_SIZE = 1024;  // 编译器可能直接内联这个值
2char buffer[BUFFER_SIZE];      // 无运行时开销
3
4const string PREFIX = "log_";  // 编译器可能优化字符串存储

引用与const

1// 最佳实践：大对象传参使用const引用
2void processLargeObject(const BigObject& obj);  // 高效
3void processLargeObject(BigObject obj);         // 低效，会产生拷贝
4
5// 返回值优化
6const BigObject& getConstObject();  // 避免不必要的拷贝

实战经验

常见陷阱

1const int a = 10;
2int* p = (int*)&a;  // 危险：强制类型转换
3*p = 20;            // 未定义行为！
4cout << a << " " << *p << endl;  // 输出可能是 10 20

最佳实践

默认使用const

1void processData(const vector<int>& data);  // 优先使用const

const成员函数设计

1class SafeContainer {
2public:
3    // 提供const和非const版本
4    const T& operator[](size_t index) const;
5    T& operator[](size_t index);
6};

线程安全考虑

 1class ThreadSafeCounter {
 2public:
 3    int getValue() const {  // const不保证线程安全
 4        std::lock_guard<std::mutex> lock(mutex_);
 5        return value_;
 6    }
 7private:
 8    mutable std::mutex mutex_;
 9    int value_ = 0;
10};

总结

使用场景	主要优势	注意事项
变量定义	防止意外修改	初始化时机很重要
指针使用	灵活控制修改权限	理解`const`位置的含义
函数参数	提高代码安全性，优化性能	合理使用引用传递
成员函数	明确函数意图，支持const对象	考虑线程安全问题
类设计	强制不变性，提高代码可维护性	合理使用`mutable`

const是C++中不可或缺的关键字，合理使用可以：

提高代码的安全性和可维护性
让编译器进行更多优化
明确开发者的意图
防止意外的数据修改

记住：在C++中，如果没有特殊理由，优先使用const！