C++ 常量（手把手讲解）

C++ 常量：不可更改的“数字守门人”

在 C++ 编程的世界里，变量就像流动的河水，随时可能改变值。但总有一些“守门人”——它们一旦被设定，就再也不允许被修改。这些“守门人”就是我们今天要聊的主角：C++ 常量。它们不只是语法糖，更是提升程序安全性和可读性的关键工具。

想象一下，你在开发一个计算器程序，需要计算圆周率。如果你把 π 写成一个普通变量，万一在某个角落不小心被改成了 3.1415926535，程序结果就会出错。但如果你把它定义为常量，编译器就会在编译阶段就“锁死”它的值，防止任何意外修改。这就是 C++ 常量的意义——让重要数据“永不动摇”。

C++ 常量不仅保障了数据的完整性，还能让代码更清晰。当你看到一个被声明为 const 的变量，你就知道它不会变，这大大降低了阅读代码时的认知负担。对于初学者来说，掌握 C++ 常量是迈向“专业级”编程的第一步。

常量的基本语法与关键字 const

在 C++ 中，定义常量最常用的方式是使用 const 关键字。它就像一个“封印符”，一旦加上，变量就再也不能被修改。

const int MAX_USERS = 100;
const double PI = 3.141592653589793;
const char DEFAULT_CHAR = 'A';

这里我们定义了三个常量：MAX_USERS 是最大用户数，PI 是圆周率，DEFAULT_CHAR 是默认字符。注意，const 必须紧跟在类型之后，且在声明时就必须初始化，否则会报错。

关键点：常量必须在定义时赋值，否则编译会失败。就像你不能把一个“锁住的盒子”先打开再锁上，必须一上来就装好东西再锁。

const 不仅适用于基本类型（如 int、double、char），也适用于指针、数组、结构体等复杂类型。它的作用是“冻结”值，而不是冻结变量本身。

const 与 #define 的区别：谁才是真正的常量？

很多初学者会问：#define 也能定义常量，比如：

#define MAX_SIZE 256

看起来效果一样，但两者本质完全不同。

来看一个例子：

#define MAX_SIZE 100
const int BUFFER_SIZE = 100;

void test() {
    int arr1[MAX_SIZE];        // 用 #define，编译器直接替换为 100
    int arr2[BUFFER_SIZE];     // 用 const，编译器知道这是一个整型常量
    // 如果你写错：int arr3[MAX_SIZE + 1.5];  // 1.5 会变成浮点，但 #define 不检查类型
    // 而 const 会报错：不能将 double 转换为 int
}

#define 只是文本替换，编译器根本不知道它代表什么类型。而 const 是真正的变量，拥有类型信息，能参与类型检查和调试。所以，在现代 C++ 中，优先使用 const 而不是 #define。

常量指针与指针常量：理解“锁”的位置

当常量与指针结合时，情况变得复杂，但也是掌握 C++ 深度的重要一步。

我们有四种组合：

1. 指针指向常量（const pointer to const）
2. 常量指针（pointer to const）
3. 指针常量（const pointer）
4. 指针指向常量（const pointer to const）

先看最常见的情况：

指针指向常量

const int* ptr = new int(42);
// *ptr = 100;  // 错误！不能通过 ptr 修改值
ptr = new int(99);  // 正确！ptr 可以指向新地址

这里的 const int* 表示“指向整型常量的指针”，意思是：你不能修改它指向的数据，但可以改变指针本身。就像你手里拿着一个“只读说明书”，你不能在上面涂改，但你可以换一本新的说明书。

指针常量

int* const ptr = new int(42);
*ptr = 100;  // 正确！可以修改值
// ptr = new int(99);  // 错误！不能修改指针

这里的 int* const 表示“常量指针”，意思是：指针本身不能变，但指向的内容可以改。就像你固定了书架的位置，但书本内容可以换。

常量指针指向常量

const int* const ptr = new int(42);
// *ptr = 100;  // 错误
// ptr = new int(99);  // 错误

这是最“锁死”的情况：指针和它指向的内容都不能改。就像把一本“永久封存”的书放在一个“固定位置”的书架上。

常量成员函数与 const 对象

在类设计中，const 的作用更加深入。我们可以为成员函数加上 const 限定符，表示这个函数不会修改对象的状态。

class Calculator {
private:
    double result;

public:
    Calculator(double val) : result(val) {}

    // 常量成员函数：不会修改对象
    double getValue() const {
        return result;  // 只读访问，安全
    }

    // 普通成员函数：可以修改对象
    void setValue(double val) {
        result = val;  // 修改成员变量
    }
};

int main() {
    const Calculator calc(100.0);  // 常量对象
    // calc.setValue(200.0);  // 错误！不能调用非 const 函数
    double val = calc.getValue();  // 正确！只能调用 const 函数
    return 0;
}

这里的关键是：常量对象只能调用 const 成员函数。这就像你不能在“只读模式”的手机上安装应用——系统会阻止你修改。

这种设计让类的接口更加清晰：哪些函数是“安全读取”，哪些是“可能修改”，一目了然。它强制了“不可变性”，是现代 C++ 设计的重要实践。

实际应用：用常量提升代码质量

让我们看一个真实场景：配置管理。

#include <iostream>
#include <string>

class Config {
public:
    const int MAX_RETRY = 3;
    const double TIMEOUT = 5.0;
    const std::string LOG_FILE = "app.log";
    const bool DEBUG_MODE = true;

    void printConfig() const {
        std::cout << "最大重试次数: " << MAX_RETRY << std::endl;
        std::cout << "超时时间: " << TIMEOUT << " 秒" << std::endl;
        std::cout << "日志文件: " << LOG_FILE << std::endl;
        std::cout << "调试模式: " << (DEBUG_MODE ? "开启" : "关闭") << std::endl;
    }
};

int main() {
    Config config;
    config.printConfig();
    return 0;
}

在这个例子中，所有配置项都声明为 const，确保程序运行期间不会被意外修改。哪怕你在其他函数中传入了 config 对象，也无法修改它的配置。

这不仅提升了代码安全性，还让维护者一眼看出：这些值是“固定的”，不需要担心它们被篡改。

总结：常量是编程的“基石”

C++ 常量不仅是语法特性，更是一种编程哲学。它教会我们：不是所有数据都该被改变。通过使用 const，我们能写出更安全、更清晰、更易维护的代码。

从简单的 const int 到复杂的 const 成员函数，每一步都在强化代码的“契约精神”——告诉编译器和同事：“这个值不会变，别动它”。

对于初学者，建议从定义基本常量开始，逐步理解 const 在指针和类中的用法。对于中级开发者，应主动在代码中使用 const 修饰函数参数、返回值和成员函数，提升代码质量。

记住：一个优秀的程序员，不是能写出多少“可变”的代码，而是能设计出多少“不可变”的部分。C++ 常量，正是通往这一境界的桥梁。