C++ 常量（建议收藏）

💡一则或许对你有用的小广告

欢迎加入小哈的星球 ，你将获得：专属的项目实战 / 1v1 提问 / Java 学习路线 / 学习打卡 / 每月赠书 / 社群讨论

• 新项目:《从零手撸：仿小红书（微服务架构）》 正在持续爆肝中，基于 Spring Cloud Alibaba + Spring Boot 3.x + JDK 17...，点击查看项目介绍 ;
• 《从零手撸：前后端分离博客项目（全栈开发）》 2 期已完结，演示链接： http://116.62.199.48/ ;

截止目前， 星球 内专栏累计输出 82w+ 字，讲解图 3441+ 张，还在持续爆肝中.. 后续还会上新更多项目，目标是将 Java 领域典型的项目都整一波，如秒杀系统, 在线商城, IM 即时通讯，权限管理，Spring Cloud Alibaba 微服务等等，已有 2900+ 小伙伴加入学习 ，欢迎点击围观

前言

在编程世界中，常量如同程序的“不变承诺”，它们为代码提供了稳定性和可预测性。在 C++ 这门语言中，常量的定义与使用贯穿于开发的各个阶段，从基础的数值固定到复杂的配置管理。无论是初学者构建第一个程序，还是中级开发者优化复杂系统，理解“C++ 常量”的核心机制都至关重要。本文将通过循序渐进的方式，结合代码示例与实际场景，深入解析 C++ 中常量的定义、类型、使用技巧以及最佳实践。

const 关键字：常量的基石

在 C++ 中，const 是定义常量的核心关键字。它通过将变量标记为“不可修改”，确保其值在程序运行期间保持不变。

基础用法：不可变的变量

最简单的 const 使用场景是声明一个常量变量。例如：

const int MAX_SIZE = 100;  
const double PI = 3.1415926535;  

这里的 MAX_SIZE 和 PI 在初始化后无法被修改。若尝试执行 MAX_SIZE = 200，编译器将直接报错，从而避免了意外的逻辑错误。

深入理解：const 的“承诺”本质

const 的设计哲学是“契约精神”。它不仅约束代码行为，还为开发者传递明确意图。例如，当函数参数被标记为 const 时，表明该参数在函数内部不会被修改：

void print(const std::string& str) {  
    // 无法执行 str = "new value"  
    std::cout << str << std::endl;  
}  

这种设计增强了代码的可维护性，因为开发者能直观判断函数是否可能改变输入数据。

const 与指针的组合：灵活的不可变性

const 可与指针结合，定义更复杂的不可变规则：

1. 指向常量的指针：指针本身可变，但指向的值不可变：

   const int value = 42;  
   int* const ptr = &value;  
   // *ptr = 100; // 错误：value 是常量  
   ptr = &another_value; // 正确：ptr 本身可变  
   

2. 常量指针指向常量：指针和值均不可变：

   const int* const ptr = &value;  
   // *ptr = 100; // 错误  
   // ptr = &another_value; // 错误  
   

通过这样的组合，const 可灵活控制数据的不可变性边界。

字面量常量：直接编码的“不可变值”

字面量常量（Literal Constants）是直接写在代码中的值，例如数字、字符或字符串。C++ 标准规定这些值在运行时不可修改，因此它们天然具备常量特性。

数值字面量与类型推断

C++ 支持多种数值字面量类型，例如：

• 5 是 int 类型
• 5u 是 unsigned int
• 5.0 是 double
• 5.0f 是 float
  开发者可通过后缀明确指定类型，避免隐式类型转换带来的精度问题。例如：

const double radius = 5.0; // 明确使用 double 类型  

字符串字面量与内存管理

字符串字面量如 "Hello World" 在内存中是静态存储的，其生命周期与程序一致。因此，直接将字面量赋值给 const char* 是安全的：

const char* message = "Hello World"; // 正确  
// message[0] = 'h'; // 错误：字符串字面量不可修改  

但需注意，直接修改字符串字面量会导致未定义行为，因此建议通过 const 修饰指针，确保其不可变性。

C++14 引入的用户定义字面量

C++14 允许开发者自定义字面量后缀，例如为物理单位（如米、秒）创建常量：

constexpr double operator"" _m(double value) {  
    return value; // 返回以米为单位的数值  
}  
const double distance = 10.5_m; // 定义距离常量  

这种设计增强了代码的可读性，将领域知识直接编码为常量。

枚举常量：类型安全的命名常量

枚举（Enum）是一种将一组命名常量组织为类型的方式，相比 #define，它提供了类型安全和作用域控制。

基础枚举：简单命名常量

enum Color {  
    RED,  
    GREEN,  
    BLUE  
};  
Color c = RED; // 正确  
// c = 5; // 错误：5 不是枚举值  

枚举值默认从 0 开始递增，但可通过赋值显式指定：

enum Status {  
    SUCCESS = 200,  
    NOT_FOUND = 404  
};  

枚举类：作用域与类型安全的升级

C++11 引入的 enum class（枚举类）解决了传统枚举的两个问题：

1. 作用域限制：枚举值需通过枚举类型名访问；
2. 类型安全：枚举值无法隐式转换为 int。

enum class Direction {  
    NORTH,  
    SOUTH  
};  
Direction d = Direction::NORTH; // 必须指定作用域  
// int value = d; // 错误：需显式转换  

枚举常量的进阶用法

枚举常量可结合 constexpr 定义，确保其在编译期计算：

enum class ErrorCode {  
    OK = 0,  
    TIMEOUT = 1,  
    INVALID = 2  
};  
constexpr auto ERROR_OK = static_cast<int>(ErrorCode::OK); // 编译期常量  

宏常量：#define 的使用与局限性

#define 是 C/C++ 中传统的常量定义方式，但其本质是预处理阶段的文本替换，存在一些潜在风险。

基础用法：简单的宏定义

#define BUFFER_SIZE 1024  
int buffer[BUFFER_SIZE]; // 正确  

宏的值直接替换代码中的出现位置，例如 BUFFER_SIZE 在预处理阶段会被替换为 1024。

宏的局限性与陷阱

1. 缺乏类型检查：宏无类型信息，可能导致隐式类型转换错误。例如：

   #define PI 3.1415926535  
   int radius = PI * 10; // 可能因类型转换导致精度丢失  
   

2. 副作用风险：宏参数若包含表达式，可能导致意外结果。例如：

   #define SQUARE(x) (x)*(x)  
   int y = SQUARE(a++); // 实际展开为 (a++)*(a++)，产生两次副作用  
   

3. 作用域问题：宏全局可见，易与其他代码冲突。

const vs #define 的选择建议

• 推荐使用 const 或 constexpr：它们具备类型安全、作用域控制和编译期优化的优势。
• 保留宏的场景：需要跨语言兼容（如 C 代码）或需文本替换的复杂场景。

进阶用法：常量在复杂场景的应用

const 成员函数：保护对象状态

在类中，const 可修饰成员函数，表明该函数不会修改对象的状态：

class Circle {  
public:  
    double get_radius() const { return radius; } // 只读方法  
private:  
    double radius;  
};  

调用 const 成员函数时，对象可为 const 类型：

const Circle circle(5.0);  
double r = circle.get_radius(); // 正确  

constexpr：编译期常量与模板

constexpr 允许函数或变量在编译期计算，常用于需要静态值的场景：

constexpr int factorial(int n) {  
    return n <= 1 ? 1 : n * factorial(n - 1);  
}  
int arr[factorial(5)]; // 编译期确定数组大小  

const_cast：谨慎的类型转换

const_cast 可用于移除或添加 const 限定符，但需严格遵循“只读原则”：

void modify(const int* ptr) {  
    int* non_const_ptr = const_cast<int*>(ptr);  
    // *non_const_ptr = 100; // 危险：若 ptr 指向常量，此操作未定义  
}  

仅在绝对必要时使用 const_cast，例如与遗留 C API 交互。

实际案例：常量在项目中的应用

场景 1：配置管理

在程序中，常量可集中管理配置参数，例如：

// config.h  
constexpr int MAX_CONNECTIONS = 100;  
constexpr std::string_view LOG_LEVEL = "DEBUG";  

修改配置时只需修改一处，避免散落的硬编码值。

场景 2：数学计算与物理公式

constexpr double G = 9.81; // 重力加速度  
double calculate_energy(double mass, double height) {  
    return mass * G * height; // 常量直接参与计算  
}  

constexpr 确保计算在编译期完成，提升性能。

场景 3：状态机与枚举

enum class State { IDLE, RUNNING, PAUSED };  
class Machine {  
    State current_state = State::IDLE;  
    void transition(State new_state) {  
        if (new_state != current_state) {  
            current_state = new_state;  
        }  
    }  
};  

通过枚举确保状态转换的合法性。

总结

“C++ 常量”不仅是代码中的固定值，更是程序设计中的关键工具。从基础的 const 变量到进阶的 constexpr 函数，常量机制贯穿于代码的可维护性、安全性和性能优化。开发者应根据场景选择最合适的常量定义方式：

• 优先使用 const 或 constexpr，确保类型安全与编译期优化；
• 谨慎使用宏，避免副作用与作用域冲突；
• 善用枚举类，提升代码的可读性与类型约束。

通过合理运用这些技术，开发者能够构建更健壮、更易维护的 C++ 程序。在实际开发中，常量如同程序的“锚点”，为复杂逻辑提供稳定的基础，帮助开发者在变化中把握不变的规则。