C/C++关键字：const

一、const的四大作用

1.修饰 内置类型：变量、数组

1.const修饰变量：
被const修饰的变量，成为只读常量，防止误修改。
const修饰变量，该变量的值在初始化后就不会再被改变。若强行修改，则编译器会报错。

const int N = 1001; //设置全局常量,算法题常用

const int a = 10;
const float b = 3.14;
const char c = 'A';

a = 11; //报错
b = 3.15; //报错
c = 'B'; //报错

2.const修饰数组：
const修饰数组，则数组中元素的值在初始化后不可被修改。

const int a[] = {1,2,3};
//a[0] = 10;  //错误

2.修饰 指针类型：常量指针、指针常量 、只读指针 (面试常问)

右左法则：
看 const 在星号 * 的哪一边：
const 在 * 左边（const int *）：修饰的是 *p（即指向的对象），所以值不能改。
const 在 * 右边（int * const）：修饰的是 p（即指针本身），所以指向不能改。

💡 一个小技巧：从右往左读。
const int * p：读作 “p is a pointer to a const int”（指向常整数的指针）。
int * const p：读作 “p is a const pointer to an int”（指向整数的常量指针）。

从内存读写权限的角度，深入理解const (花生老师讲解)：https://blog.csdn.net/Edward1027/article/details/138280628

(1)常量指针：const int *p

const 在 * 左边 (const int * p、int const * p)，修饰的是 *p (即指向的对象)，所以值不能改。
指针可以改变指向哪个变量，但不能通过p这个指针来修改变量的值。

指向可以改变：✅ p 本身是一个普通指针变量，你可以让它指向另一个变量。例如 p = &another_var; 是合法的。
无法通过 p 修改值：✅ *p 被视为常量，不能作为左值被赋值。例如 *p = 10; 编译器会直接报错。

//常量指针: 指向常量,不能修改变量的值,但可以修改指针的指向
int a = 1, b = 2;
const int* p;  //或者 int const* p = &a;
p = &a;
printf("*p = %d\n", *p);
p = &b;       //指针的指向可以修改
printf("*p = %d\n", *p);
*p = 3;       //报错,不能修改指向的变量的值

(2)指针常量：int * const p

const在 *的右边 (const在*和p中间，int * const p)，const修饰的是 p (指针本身)，即指针p是个常量，所以指针的指向不可修改，但是可以通过指针修改所指向的变量的值。

指针是个常量，指针的指向不可修改，但是指向的变量的值可以改变

int a = 1, b = 2;
//指针常量:p的指向不可被修改
int* const p = &a;
*p = 3;   //可以修改变量的值
printf("a = %d\n", a); 
p = &b;   //报错:指针的指向不可被修改

(3)只读指针：const int * const p

两个const，表示 变量的值和指针的指向都不可修改 const int * const p

int a = 1, b = 1;
const int * const ptr3 = &a;
//ptr3 = &b; //错误:只读指针,指针的指向不可改变
//*p3 = 10;  //错误:只读指针,指针指向的值不可修改

3.修饰 函数的形参、修饰 引用 (最常用）

1.const修饰 函数的形参：【传入参数】
可以避免传递过来的值，在函数体内部被误修改。

void printString(const char* str){  //等价于const char str[]
	cout << "String:" << str << endl;
}

2.const 修饰 引用 (最常用)：
引用避免了拷贝、const避免了函数对值的修改。
明确告诉函数的使用者，该参数在经过函数调用时不会被修改，提高了代码的清晰度和安全性。

void setName(string name){ //应优化为 const string &name
	m_name = name;
}

void printName(const string &name) {
    cout << "Name: " << name << endl;
    // name = "Sam"; // 错误：不能修改const引用指向的值
}

4.修饰 类的成员函数(const成员函数)、修饰 类的对象(const对象)

1.const 修饰 类的成员函数：
常成员函数 不会修改任何成员变量。
成员函数后面加const，则该成员函数不可修改类的成员变量。除非成员变量前面加了关键字mutable

void test(int x) const;

#include <iostream>

class Test {
public:
    int x;
    mutable int y;  // 可以在const成员函数中被修改

    Test(int val):x(val),y(0){
    	//使用初始化列表,直接对成员变量初始化
    } 

    void modify() const {  // const成员函数
        // x++;  // 错误：不能在const成员函数中修改非mutable成员
        y++;  // 正确：可以修改mutable成员
    }
};

int main() {
    Test t(10);
    t.modify();
    std::cout << "t.y = " << t.y << std::endl;  // 输出 t.y = 1
    return 0;
}

2.const 修饰 类的对象：
常对象(const对象) 只能调用 常成员函数(const成员函数)：被const修饰的对象，只能调用类中 结尾带const的成员函数。

const People p;