1.在C语言中
在C语言中,const 是一个关键字，用于修饰变量。
它的主要作用是定义常量，即被 const 修饰的变量的值不能被修改。
例如:
const int a = 10;
//这里定义了一个整型常量 a ，尝试给 a 重新赋值（如 a = 20; ）会导致编译错误。
const 也可以用于修饰指针。如果是 const 在 * 之前，如 const int *p ，表示指针 p 所指向的内容是常量，不能通过 p 来修改它指向的内容，但 p 本身可以指向其他地址；如果 const 在 * 之后，如 int * const p ，则表示指针 p 本身是常量，不能再指向其他地址，但可以通过 p 修改它指向的内容；如果写成 const int * const p ，那么 p 所指向的内容和 p 本身都不能被修改。
int const *p;//表示*p不能被修改
int *const p;//表示 p 不能被修改
const int *const p;//表示*p 和 p 都不能被修改
2.在C++中
在C++中， const 关键字和C语言中的类似，但也有一些拓展。
1）. 定义常量
- 用于定义基本数据类型常量，如 const int num = 10; ，这里 num 的值在初始化后不能被改变。这有助于提高程序的安全性和可读性，避免意外修改数据，但是可以通过指针修改。
const int a=2;
const int *p=&a;
//首先将p从const类型的指针转换成非const：
int *p1=const_cast<int*>p;//const_cast是C++的四种强转类型之一，可以看我之前发过的文章
*pl=3;
cout<<*p<<" "<<*pl;
2）. 修饰指针
- const 修饰指针和C语言类似。 const int *p 表示 p 指向的内容是常量； int * const p 表示指针 p 本身是常量； const int * const p 表示 p 指向的内容和 p 本身都是常量。
#include<iostream>
using namespace std;
int mian()
{
const int *p;//*p不能被修改
int const *p2;
int a=2;
int *const p1=&a;//修饰p1不能被修改，并且p1必须要初始化
3）. 修饰函数参数
- 当函数参数是 const 引用（如 void func(const int& n) ）时，函数内部不能修改引用所绑定的对象。这在传递大型对象时可以避免复制开销，同时保证对象不被修改。
- 对于指针参数， const 也有类似作用。例如 void func(const char* str) ，函数内部不能通过 str 修改它所指向的字符串内容。
4）. 修饰函数返回值
- 当函数返回值是 const 时，返回的对象不能被修改。例如 ：const int& getValue() 返回一个 const 引用，调用这个函数得到的结果不能用于修改原对象。
5）. 类中的const
- 在类中， const 成员函数是一个重要的概念。在 const 成员函数（如 void classA::func() const ）中，不能修改类的非 const 成员变量。这保证了在调用 const 对象的成员函数时，对象的状态不会被意外改变。
注意：
在C++类中，const修饰成员函数时，此函数称为常函数，修饰对象，称为常对象
1.常函数
1）.成员函数后加const修饰，此函数称为常函数
2）.常函数内不可以修改成员属性，也不可以调用非常函数（类型不匹配）
3）.成员属性声明时加上关键字mutable后，可以在常函数中被修改
4）.如果两个函数名相同，参数相同，但是一个是常函数一个是非常函数，那么这两个函数为函数重载，非常对象优先调用非常函数，常对象只能调用常函数
5）.常函数能修改静态成员变量，因为访问静态成员变量不需要this指针
6）.常函数可以调用静态成员函数，因为静态成员函数没有this指针，this指针类型不冲突
7）.常函数中的this：const A* const this
*this和this都被const修饰了，修饰*this意味着*this不能被修改
也就是这个对象不能在常函数中被修改（常函数不能修改成员变量原因）
2.常对象
1）.声明对象前加const，此对象称为常对象
2）.常对象只能调用常函数
3）.常对象不能被修改，常对象只能调用常函数， 因为非常函数会修改常对象中的成员变量
4）.非常对象允许被修改，非常对象既能调用非常函数， 又可以调用常函数，优先调用非常函数
#include<iostream>
using namespace std;
class A {
int num;
static int a;
public:
A() {
num = 1;
}
void set_num(int num) {
this->num = num;
}
int get_num()const {//成员函数后加const修饰，变成常函数
//this->num=3;常函数不能修改非静态成员变量，因为*this被const修饰了
//set_num(2);常函数不能调用非常函数，类型不匹配
a = 3;//常函数能修改静态成员变量，因为访问静态成员变量不需要this指针
//常函数可以调用静态成员函数，因为静态成员函数没有this指针，this指针类型不冲突
cout << " 常函数" << endl;
return this->num;//this:const A* const this
/*常函数中的this：const A* const this
*this和this都被const修饰了，修饰*this意味着*this不能被修改
也就是这个对象不能在常函数中被修改（常函数不能修改成员变量原因）*/
}
int get_num() {
//因为常函数和非常函数中的this指针类型不同，所以他们互为重载关系
cout << "非常函数" << endl;
return 0;
}
};
int A::a = 2;
int main() {
/*常对象不能被修改，常对象只能调用常函数，
因为非常函数会修改常对象中的成员变量*/
/*非常对象允许被修改，非常对象既能调用非常函数，
又可以调用常函数，优先调用非常函数*/
}