*常量指针（int const p） → 顶层 const
- 指针本身不可变
- 可修改指向对象的值
- 声明形式：int *const ptr = &some_int_var;
*指向常量的指针（const int p） → 底层 const
- 指针可变
- 不能通过 p 修改值
- 声明形式：const int *ptr = &some_const_int_var
const 引用
- 绑定临时变量
- 防止修改
const 成员函数
- 隐含 this = const T* const this
- 不能修改成员（除 mutable）

3. 图表总结

声明	含义	能否改指针	能否改值
const int *p	指向常量的指针	✔	❌
int *const p	常量指针	❌	✔
const int *const p	指向常量的常量指针	❌	❌
int const *p	与 const int* 相同	✔	❌

4. 示例代码

// 1. 常量变量
const int a = 10;
// a = 20;  // ❌ 错误：a 是常量，不能修改



// 2.指向常量的指针（pointer to const）
int x = 10, y = 20;
const int* p = &x;  // 指向常量的指针（底层 const）
p = &y;        // ✔ 指针能改
//*p = 30;     // ❌ 无法修改 *p


// 3.常量指针（const pointer）
int x = 10;
int* const p = &x;  // 常量指针（顶层 const）
*p = 99;     // ✔ 修改值
//p = &y;     // ❌ 指针不能改地址


// 4.常量引用（const reference）
int x = 10;
const int& r = x;   // 常量引用
// r = 20;          // ❌ 不能改
// r++;             // ❌ 不能改


// 5.const 成员函数（class A::func() const）
class A {
public:
    int val = 0;

    int get() const {  
        // val = 10;  // ❌ 不允许修改对象
        return val;   //  ✔ 读取没问题
    }

    void set(int v) {
        val = v;  //     ✔ 普通成员函数可以修改成员
    }
};

int main() {
    A obj;
    obj.set(100);   // ✔ 普通对象能调普通函数
    obj.get();      // ✔ 普通对象能调 const 函数

    const A obj2;   //  关键！
    // obj2.set(10);  ❌ const 对象不能调用非 const 函数
    obj2.get();       // ✔ const 对象只能调用 const 函数
}

5. const 关键字总结

常量变量：声明常量，使变量的值不能被修改。
指针和引用：声明指向常量的指针，表示指针所指向的值是常量，不能通过指针修改。声明常量引用，表示引用的值是常量，不能通过引用修改。

const int* ptr = &constantValue;  // 指向常量的指针
const int& ref = constantValue;  // 常量引用

成员函数：用于声明常量成员函数，表示该函数不会修改对象的成员变量（对于成员变量是非静态的情况）。
常量对象：声明对象为常量，使得对象的成员变量不能被修改。
常引用参数：声明函数参数为常量引用，表示函数不会修改传入的参数。
常量指针参数：声明函数参数为指向常量的指针，表示函数不会通过指针修改传入的数据。
const 对象只能调用 const 成员函数，因为 const 成员函数保证不会修改对象状态。
普通成员函数可能修改对象状态，因此被 const 对象禁止调用。

6.面试一句话总结

const 的作用是提供只读保护，它可以修饰变量、指针、引用、对象和成员函数。
变量加 const 表示值不能改；
const int* 是指向常量的指针（不能改值但能换指向）；
int* const 是常量指针（能改值但不能换指向）；两者都加 const 是指向常量的常量指针，都不能改；
const 引用常用于函数参数，既避免拷贝又保证不修改传入对象；
把对象声明为 const 后，它只能调用 const 成员函数，因为 const 成员函数的 this 是 const T* const，承诺不修改对象状态。

总结来说：

const 通过“顶层/底层 const”机制给 C++ 提供了完整的只读体系，使代码更安全、更易优化。

二、static 关键字

1. 简要回答

static：延长生命周期（全局数据区）、限制可见性（内部链接）、在类中实现共享（静态成员变量）和无 this 的类函数（静态成员函数）。

2. 详细回答

1）静态变量（包含：全局静态变量、静态局部变量）

（1）全局静态变量（`static int g;`）

定义在函数外、文件作用域，用 static 修饰的全局变量。
生命周期：程序开始到程序结束（和普通全局变量一样）。
作用域：仅当前源文件可见，其他文件不能通过 extern 访问到。
存储位置：全局/静态存储区。
作用：隐藏实现细节，避免全局变量“污染”整个工程的符号表（内部链接）。

（2）静态局部变量（`static int local;`）

定义在函数内，用 static 修饰的局部变量。
生命周期：程序开始到结束（不会因为函数返回而销毁）。
作用域：仅当前函数内可见。
特点：
- 只初始化一次（第一次执行到定义处时初始化）。
- 后续调用保留上一次的值，很适合做“记数器”、“缓存”。

静态局部变量在第一天的全局变量/静态局部变量/局部变量中进行的详细的讲解。以下是链接：

【C++基础】Day 1：全局/静态/局部变量、指针 vs 引用、整型类型-CSDN博客https://blog.csdn.net/m0_58954356/article/details/154984198?spm=1001.2014.3001.5501

2）静态成员变量（`static int ExampleClass::staticVar;`）

定义在类内、用 static 修饰的成员变量。
不属于某个对象，而是属于整个类：所有对象共享一份。
静态成员变量必须在类外部单独定义，以便为其分配存储空间

class ExampleClass {
public:
    static int staticVar;  // 静态成员变量声明
};

// 静态成员变量定义
int ExampleClass::staticVar = 0;

生命周期：程序整个运行期间。
用途：
- 用来统计“类一共创建了多少对象”；
- 用来做类级的配置、缓存等。

3）静态成员函数（`static void staticMethod();`）

在类内部用 static 关键字修饰的成员函数是静态成员函数
没有 this 指针：
- 不能访问普通成员变量/函数（因为没有具体对象）。
- 只能访问静态成员变量/静态成员函数。
调用方式：
- 可以用类名直接调用：ExampleClass::staticMethod( )，而不需要创建类的实例

class A {
public:
    static void foo() {
        cout << "I am class-level function" << endl;
    }
};

本质：

“写在类里的普通函数”，只不过用类作为命名空间 + 可以访问类的静态数据。

4）静态函数（类外，文件内 static 函数）

在 文件作用域（全局区） 使用 static 修饰的函数：

static void helper() {
    cout << "I am file-local" << endl;
}

限制函数只在当前 .cpp 文件内可见（内部链接）

其他文件无法 extern 引用它

常用于隐藏库内部实现，避免全局符号污染

5）静态函数和静态成员函数对照

对比项	静态函数（static function）	静态成员函数（static member function）
语言层级	C / C++	C++（类）
作用域	文件作用域	类作用域
可见性	仅当前文件可见	类内可见，通过类名访问
是否属于对象	❌ 不属于对象	❌ 不属于对象（属于类）
是否有 this	❌ 无 this	❌ 无 this
调用方式	仅当前文件内调用	类名::函数或对象.函数
是否能访问普通成员变量	❌ 不能	❌ 不能（因为没 this）
是否常与静态成员变量搭配	❌ 不相关	✔ 常一起使用
用途	隐藏函数（模块内实现）	类级工具函数、管理静态成员变量

3. 图表总结

1）按“作用对象”分类

用法	代码例子	作用对象	生命周期	作用域 / 可见性
全局静态变量	`static int g;`	变量	整个程序	当前源文件内
静态局部变量	`static int x;`（在函数内）	变量	整个程序	当前函数内
静态成员变量	`static int Example::cnt;`	类共享变量	整个程序	类内访问（但存储在类外）
静态成员函数	`static void foo();`	类级函数（无 this）	程序整个期	类内/类名可调用
文件内静态函数	`static void helper();`	函数符号	由编译单元决定	当前源文件

2）“是否和对象相关”

是否依赖对象	用法	说明
依赖对象	普通成员变量 / 成员函数	需要对象，有 this
不依赖对象	静态成员变量 / 静态成员函数	属于类级别，无 this

4. 示例代码

1）静态函数：只能本文件使用（模块级封装）

//  a.cpp

static void helper() {   // 外部文件看不到
    cout << "helper" << endl;
}

void api() {
    helper();  // OK
}

//  b.cpp

extern void helper();  // ❌ 链接失败：helper 是内部链接

静态函数 = 隐藏在当前 .cpp 内部的工具函数。

2）静态成员函数：属于类，无需对象

class Math {
public:
    static int add(int a, int b) {
        return a + b;
    }
};

// 调用
int x = Math::add(1, 2);

常用于提供“类级工具函数”，如数学函数、配置设置等。

3）静态局部变量：计数器例子

#include <iostream>
using namespace std;

void foo() {
    static int count = 0;  // 只初始化一次
    count++;
    cout << "foo called " << count << " times\n";
}

int main() {
    foo(); // 1
    foo(); // 2
    foo(); // 3
}

说明：count 不会随着 foo() 返回而销毁，每次调用都会在上次基础上累加。

5. 知识拓展（面试回答加分点）

1）static 和多线程

静态局部变量、静态成员变量在多线程环境下是共享的，需要考虑加锁。
C++11 之后，函数内的 static 局部变量初始化是线程安全的：

static Example instance;  // 第一次调用时安全初始化（C++11）

2）static 成员和单例模式

单例模式常用：

class Singleton {
public:
    static Singleton& instance() {
        static Singleton inst; // 函数内 static，懒汉模式 + 线程安全初始化
        return inst;
    }
private:
    Singleton() {}
};