C++中const修饰符的作用及使用误区有哪些？

// 宏定义常量（不推荐）
#define PI_MACRO 3.14159
// const定义常量（推荐）
const double PI_CONST = 3.14159;
// C++11及以后推荐用constexpr明确表示编译期常量
constexpr double PI_CONSTEXPR = 3.14159;
void test_const_var() {
    // PI_CONST = 3.14; // 编译错误：const变量不可修改
    int a = PI_MACRO + 1; // 预处理后变成 3.14159 + 1，无类型检查
    int b = PI_CONST + 1; // 编译警告：double转int丢失精度，有类型检查
}

int a = 10;
int b = 20;
// 1. 底层const：指向的内容不可修改，指针本身可以改
const int *p1 = &a; // 等价于 int const *p1 = &a;
// *p1 = 100; // 编译错误：底层const，不能修改指向的内容
p1 = &b; // 合法：指针本身可以改指向
// 2. 顶层const：指针本身不可修改，指向的内容可以改
int *const p2 = &a;
*p2 = 100; // 合法：可以修改指向的内容
// p2 = &b; // 编译错误：顶层const，指针本身不可改指向
// 3. 同时有顶层和底层const：指针和指向的内容都不可改
const int *const p3 = &a; // 等价于 int const *const p3 = &a;
// *p3 = 100; // 编译错误
// p3 = &b; // 编译错误

// 错误：非const左值引用不能绑定临时对象
// string &r1 = string("hello");
// 正确：常引用可以绑定临时对象，生命周期延长到r2的作用域
const string &r2 = string("hello");
// 函数传参用常引用，高效又安全
void print_str(const string &s) {
    // s += "world"; // 编译错误：常引用不可修改
    cout << s << endl;
}
print_str("hello"); // 合法："hello"转为临时string，绑定到const引用

// 头文件声明：传值参数不需要写const，顶层const不影响签名
void func(int a, const string &s);
// 实现里可以给传值参数加const，防止内部意外修改
void func(const int a, const string &s) {
    // a = 10; // 编译错误：形参a是const
    // s += "a"; // 编译错误：s是const引用
    cout << a << s << endl;
}

class Person {
private:
    string name;
public:
    // 返回const引用：外部不能修改成员变量name
    const string& get_name() const { return name; }
};
Person p;
// p.get_name() = "zhangsan"; // 编译错误：返回的是const引用，不可修改

class Person {
private:
    string name;
    mutable int visit_count = 0; // mutable修饰的变量，允许在const函数中修改
public:
    // 普通成员函数：可以修改成员变量
    void set_name(string n) {
        name = move(n);
    }
    // 常成员函数：不修改成员变量
    const string& get_name() const {
        visit_count++; // 合法：visit_count是mutable
        return name;
    }
};
// const对象只能调用常成员函数
const Person p_const;
p_const.get_name(); // 合法
// p_const.set_name("lisi"); // 编译错误：const对象不能调用非const成员函数
// 非const对象优先调用非const版本（如果有的话）
Person p;
p.set_name("zhangsan"); // 合法
p.get_name(); // 合法：非const对象也可以调用const成员函数

const int a = 10;
const int *p1 = &a; // p1是底层const
int *p2 = p1; // 编译错误！不能把底层const指针赋值给非底层const指针
// 如果允许上述操作，就可以通过p2修改const变量a的值，违反了const语义

int b = 20; // 原对象本身是非const的
const int *p1 = &b;
int *p2 = const_cast<int*>(p1); // 合法，且行为定义：b本身可修改
*p2 = 100; // 合法，b被修改为100

class Person {
private:
    string name;
public:
    // 错误：get_name不会修改成员变量，但没加const
    string& get_name() {
        return name;
    }
};
const Person p;
// p.get_name(); // 编译错误：const对象不能调用非const成员函数

class Person {
private:
    string name;
public:
    // 非const版本：给非const对象调用，返回可修改的引用
    string& get_name() {
        return name;
    }
    // const版本：给const对象调用，返回const引用
    const string& get_name() const {
        return name;
    }
};

void print_str(string &s) {
    cout << s << endl;
}
// print_str("hello"); // 编译错误："hello"转为临时string，不能绑定到非const引用
// print_str(string("world")); // 编译错误：同样是临时对象

void print_str(const string &s) { // 加const
    cout << s << endl;
}
print_str("hello"); // 合法

#define MAX 1024
const int MAX = 2048; // 编译错误：宏MAX被替换为1024，变成 const int 1024 = 2048; 语法错误

// #define MAX 1024 // 删掉宏
constexpr int MAX = 1024; // 用constexpr代替

int n = rand();
const int SIZE = n; // 运行期初始化，不是编译期常量
// int arr[SIZE]; // 编译错误：C++标准不支持变长数组（VLA是GCC扩展，非标准）

constexpr int SIZE = 1024; // 编译期常量
int arr[SIZE]; // 合法

// 编译错误：重复定义，顶层const不影响签名
void func(int a) {}
void func(const int a) {} // 和上面的func是同一个函数
// 编译错误：重复定义，指针的顶层const不影响签名
void func(int *p) {}
void func(int *const p) {} // 和上面的func是同一个函数

// 合法重载：指针的底层const不同
void func(int *p) {}
void func(const int *p) {} // 不同的函数
// 合法重载：引用的底层const不同
void func(int &a) {}
void func(const int &a) {} // 不同的函数
// 合法重载：成员函数的const（底层const修饰this）
class Person {
public:
    void func() {}
    void func() const {} // 不同的函数
};

class Order {
private:
    mutable int amount; // 订单金额是核心状态，不该用mutable
public:
    // const函数修改核心状态，逻辑错误
    void set_amount(int a) const {
        amount = a; // 因为mutable编译通过，但语义错误
    }
};

const string& get_name() {
    string name = "zhangsan";
    return name; // 错误：返回局部对象的引用，函数结束后name被销毁
}
// string s = get_name(); // 未定义行为：引用悬空，可能崩溃、可能乱码

string get_name() {
    string name = "zhangsan";
    return name; // 合法，返回值会被移动/拷贝
}

// 预期：不能修改指向的内容，指针可以改指向
int *const p = &a; // 实际：指针不能改指向，内容可以改
*p = 100; // 编译通过，但不符合预期