C++ const 完整语法整理

核心口诀：左数右指

• const 在 * 左边 → 修饰「指针指向的内容」（数据只读，指针可移动）；
• const 在 * 右边 → 修饰「指针本身」（指针地址只读，指向的内容可改）；

示例

int a = 10, b = 20;

// 场景 1：数据只读，指针可移
const int* p1 = &a;
// *p1 = 30; // 错误：内容只读
p1 = &b; // 正确：指针可移动

// 场景 2：指针只读，数据可改
int* const p2 = &a;
*p2 = 30; // 正确：内容可改
// p2 = &b; // 错误：指针地址只读

// 场景 3：全只读
const int* const p3 = &a;
// *p3 = 30; // 错误
// p3 = &b; // 错误

场景 3：const 修饰引用（const 引用）

语法

const 类型& 引用名 = 变量/常量/临时值;

核心作用

1. 禁止通过引用修改原变量（引用只读）；
2. 可绑定常量 / 临时值（普通引用只能绑定可修改的左值）；
3. 绑定临时值时，临时值的生命周期会被延长至引用的生命周期结束。

示例

int a = 10;
const int& ref1 = a; // ref1 = 20; // 错误：引用只读
const int& ref2 = 100; // 正确：const 引用可绑定常量
double b = 3.14;
const int& ref3 = b; // 正确：临时值（int(b)）绑定到 const 引用，生命周期延长

典型用途

函数参数传递（避免拷贝 + 防止修改）：

// 自定义类型参数：const& 避免拷贝，且禁止修改参数
void printCircle(const Circle& c) {
    cout << c.calculateArea() << endl; // 只能调用 c 的 const 成员函数
}

场景 4：const 修饰函数参数

语法

// 基础类型（传值，const 仅约束函数内）
void func(const int num) { /* num 不可改 */ }

// 自定义类型（推荐 const&，避免拷贝 + 防修改）
void func(const Circle& c) { /* c 不可改 */ }

// 指针参数（const 修饰指向的内容）
void func(const int* p) { /* *p 不可改 */ }

核心作用

• 禁止函数内修改参数值，提升代码安全性；
• 对自定义类型（如 Circle），结合引用（const&）可避免拷贝，大幅提升效率；
• 基础类型（int/double）传值时加 const，仅约束函数内，对外部无影响（可加可不加）。

场景 5：const 修饰函数返回值

语法与作用

仅对「指针 / 引用返回值」有实际意义（基础类型返回值是拷贝，const 无作用）：

// 场景 1：返回 const 指针（禁止修改返回的内容）
const int* func1(int* arr) {
    return arr;
}

// 场景 2：返回 const 引用（禁止外部修改类成员）
class Circle {
private:
    double radius;
public:
    const double& getRadius() const {
        return radius;
    }
};

示例

int arr[] = {1, 2, 3};
const int* p = func1(arr);
// *p = 10; // 错误：返回的指针指向内容只读

Circle c(5.0);
// c.getRadius() = 10; // 错误：返回的引用只读

场景 6：const 修饰类成员（核心！分变量 + 函数）

子场景 6.1：const 成员变量（类内常量）

语法（两种初始化方式）

• C++11 及以上：类内直接初始化（简洁）；
• 所有 C++ 版本：构造函数初始化列表初始化（兼容推荐）。

// 写法 1：C++11+ 类内直接初始化
class Circle {
private:
    const double PI = 3.14159; // 类内初始化 const 成员
    double radius;
public:
    Circle(double r) : radius(r) {}
};

// 写法 2：初始化列表初始化（兼容所有版本）
class Circle {
private:
    const double PI; // 仅声明，不赋值
    double radius;
public:
    // 必须在初始化列表初始化 const 成员（不能在构造函数体赋值）
    Circle(double r) : PI(3.14159), radius(r) {}
};

关键补充：静态 const 成员变量

若常量是所有对象共享的（如 PI），加 static 修饰，减少内存开销（所有对象共用一份）：

class Circle {
private:
    static const double PI = 3.14159; // 静态常量，类内初始化
    double radius;
};

// （可选）类外定义（若需跨文件访问）
const double Circle::PI = 3.14159;

子场景 6.2：const 成员函数（常量成员函数）

语法

返回值 函数名 (参数列表) const;
// const 在参数列表后

核心作用

1. 约束函数不修改对象状态：this 指针变为 const 类名*（只读指针），不能修改类的非 mutable 成员变量；
2. 支持 const 对象调用：const 对象只能调用 const 成员函数（非 const 对象可调用 const / 非 const 函数）；
3. 语义标注：明确函数是'只读操作'，提升可读性。

示例（Circle 类）

class Circle {
private:
    double radius;
    mutable int calcCount = 0; // mutable：const 函数中可修改
public:
    double calculateArea() const {
        // const 成员函数
        calcCount++; // 合法：mutable 变量不受 const 约束
        // radius = 10; // 错误：不能修改非 mutable 成员
        return PI * radius * radius;
    }
    void setRadius(double r) {
        // 非 const 成员函数
        radius = r;
    }
};

// 使用场景
const Circle c1(5.0);
c1.calculateArea(); // 正确：const 对象调用 const 函数
// c1.setRadius(6.0); // 错误：const 对象不能调用非 const 函数

Circle c2(5.0);
c2.calculateArea(); // 正确：非 const 对象可调用 const 函数
c2.setRadius(6.0); // 正确：非 const 对象调用非 const 函数

补充：mutable 关键字（const 函数的例外）

mutable 修饰的成员变量，可突破 const 函数的约束（用于统计、缓存等不影响对象核心状态的场景）：

class Circle {
private:
    mutable int calcCount = 0; // 可在 const 函数中修改
public:
    double calculateArea() const {
        calcCount++; // 合法：统计函数调用次数
        return PI * radius * radius;
    }
};

场景 7：const 修饰对象（const 对象）

语法

const 类名 对象名 (构造参数);

核心作用

对象只读：只能调用 const 成员函数，不能修改任何成员变量（包括非 const 成员）。

示例

const Circle c(5.0);
// c.setRadius(6.0); // 错误：const 对象不能调用非 const 函数
cout << c.calculateArea() << endl; // 正确：调用 const 函数

三、核心规则与易错点

1. const 是编译期约束：仅在编译阶段检查，若通过 const_cast 强制修改 const 变量，会导致'未定义行为'（可能崩溃 / 数据异常）；
2. const 的顺序：
   • 普通变量：const int a 和 int const a 等价；
   • 指针：const int* p 和 int const* p 等价（左数），int* const p（右指）不同；
3. const 引用绑定临时值：临时值（如 10、表达式结果）的生命周期会被 const 引用延长至引用生命周期结束；
4. const 成员函数调用规则：
   • const 成员函数 → 只能调用其他 const 成员函数（避免间接修改对象）；
   • 非 const 成员函数 → 可调用 const / 非 const 成员函数。

const int num = 10;
int* p = const_cast<int*>(&num);
*p = 20; // 未定义行为！编译器可能优化 num 为常量折叠，num 仍为 10

四、常量正确性（Const Correctness）规范

遵循以下规范，可大幅减少编程错误：

1. 所有只读数据（如 PI）用 const 修饰；
2. 所有不修改对象状态的成员函数加 const；
3. 函数参数若无需修改，加 const（尤其是自定义类型的引用 / 指针参数）；
4. const 对象仅调用 const 成员函数，非 const 对象按需调用；
5. 静态常量成员加 static const，减少内存开销。

总结