C++ const常量用法完整详解

const 用于修饰只读对象，被修饰后值不可修改，有类型、作用域，是 C++ 主力常量用法。下面分场景逐一讲解。

一、基础：修饰普通变量（常量变量）

1. 基本语法

const 类型 变量名 = 初始值;

强制要求：必须初始化，定义后不能再赋值修改。

#include <iostream>
using namespace std;
int main()
{
    const int num = 100;
    const double pi = 3.14159;
    // num = 200;  // 编译报错：const 只读，无法修改
    cout << num << " " << pi << endl;
    return 0;
}

2. 作用域规则

• 局部 const：定义在函数/代码块内，仅当前作用域有效。
• 全局 const：默认仅当前源文件可见（内部链接），和普通全局变量不同。
  • 若要跨文件使用，加 extern：

// 文件A.cpp
extern const int g_val = 10;
// 文件B.cpp
extern const int g_val; // 声明，可使用

3. 用变量初始化 const

const 可以是运行时常量，允许用普通变量初始化：

int a = 20;
const int b = a; // 合法，运行时确定值

二、重点：const + 指针（三大组合，高频考点）

根据 const 位置不同，含义完全不同，分三类记忆。

1. 常量指针（const修饰指向的内容）

格式：const 类型* 指针名

• 指针本身可以改指向
• 指针指向的数据不能修改

int x = 1, y = 2;
const int* p = &x;
p = &y;        // ✅ 指针指向可以变
// *p = 100;   // ❌ 指向的值不能修改

2. 指针常量（const修饰指针本身）

格式：类型* const 指针名

• 指针本身不能改指向（必须初始化）
• 指针指向的数据可以修改

int x = 1;
int* const p = &x; // 定义时必须初始化
*p = 100;      // ✅ 内容可改
// p = &y;     // ❌ 指针指向不能变

3. 双重 const（内容、指针都只读）

格式：const 类型* const 指针名

• 指针指向 不能改
• 指向的数据 不能改

int x = 1;
const int* const p = &x;
// *p = 100;  ❌
// p = &y;    ❌

快速判断技巧：看 const 靠近谁，谁就不能改。

三、const 修饰引用

引用本身等价于变量别名，const 修饰引用表示不能通过引用修改原数据。

格式：const 类型& 引用名

int a = 10;
const int& r = a;

// r = 20;  // ❌ 不能通过引用修改 a
a = 20;    // ✅ 原变量本身可以修改

常用场景：函数传参，避免拷贝 + 保护数据。

四、const 修饰函数（分：参数、返回值、成员函数）

1. 修饰函数形参

目的：保护实参不被函数修改，推荐搭配引用/指针使用，减少拷贝。

// 不允许修改传入的字符串
void print(const string& s)
{
    cout << s << endl;
    // s = "test"; 报错
}

2. 修饰函数返回值

一般用于返回指针/引用，防止外部修改返回的内容：

const int& getVal(int& a)
{
    return a;
}
int main()
{
    int x = 10;
    const int& res = getVal(x);
    // res = 20; 报错
    return 0;
}

普通值返回加 const 无意义。

3. 修饰类的成员函数（类专属用法）

const 写在函数参数列表后面，表示：

该函数不会修改类的任何成员变量，也不能调用非 const 成员函数。

语法：

返回值 函数名(参数) const;

示例：

class Test
{
private:
    int num = 10;
public:
    // const 成员函数
    void show() const
    {
        cout << num << endl;
        // num = 20;  ❌ 不能修改成员变量
    }
};

规则：

1. const 成员函数内，禁止修改成员变量。
2. const 对象只能调用 const 成员函数。
3. const 成员函数不能调用普通（非 const）成员函数。

五、const 修饰类成员变量

类内 const 成员变量，必须在构造函数初始化列表初始化，不能在构造函数体内赋值。

class A
{
private:
    const int val; // const 成员
public:
    // 只能在初始化列表赋值
    A() : val(100) 
    {
        // val = 100;  ❌ 体内赋值报错
    }
};

六、补充：const 与 类型转换、const _cast

1. const 变量不能直接转普通变量，强行修改属于未定义行为。
2. 若临时需要去除只读属性，可用 const_cast（谨慎使用）：

const int a = 10;
int* p = const_cast<int*>(&a);
*p = 20; // 不推荐，修改原 const 常量是未定义行为

七、const 总结速记

1. 普通变量：const 类型 变量 = 值，只读不可改。
2. 指针：
   • const T*：内容不可改，指针可改
   • T* const：指针不可改，内容可改
   • const T* const：全都不可改
3. 引用：const T&，禁止通过引用改原数据。
4. 函数参数：const 保护实参，优先引用传参。
5. 类成员函数：尾部加 const，承诺不修改成员。
6. 类 const 成员变量：必须在初始化列表初始化。