const 是C++中常用的类型修饰符,常类型是指使用类型修饰符const说明的类型，常类型的变量或对象的值是不能被更新的。
目录
一、const的作用
二、const修饰普通类型的变量
三、const修饰指针变量
四、const参数传递和函数返回值。
五、const修饰类成员函数。
总结
参考文档
一、const的作用
const的作用如下表所示：
| No. | 作用 | 说明 | 参考代码 |
| 1 | 可以定义const常量 | | const int Max = 100; |
| 2 | 便于进行类型检查 | const常量有数据类型，而宏常量没有数据类型。编译器可以对前者进行类型安全检查，而对后者只进行字符替换，没有类型安全检查，并且在字符替换时可能会产生意料不到的错误。 | void f(const int i) { ......... } //对传入的参数进行类型检查，不匹配进行提示 |
| 3 | 可以保护被const修饰的东西 | 防止意外的修改，增强程序的健壮性。 | void f(const int i) { i=10;//error! }
//如果在函数体内修改了i，编译器就会报错 |
| 4 | 可以很方便地进行参数的调整和修改 | 同宏定义一样，可以做到不变则已，一变都变。 | |
| 5 | 为函数重载提供了一个参考 | | class A
{
public:
void f(int i){......} //一个函数
void f(int i) const {......} //上一个函数的重载
}; |
| 6 | 可以节省空间，避免不必要的内存分配 | const定义常量从汇编的角度来看，只是给出了对应的内存地址，而不是象#define一样给出的是立即数，所以，const定义的常量在程序运行过程中只有一份拷贝，而#define定义的常量在内存中有若干个拷贝 | #define Pi 3.14159 //常量宏 double a=pi; //编译期间进行宏替换，分配内存 double b=Pi; //再进行宏替换，又一次分配内存！ ......
const doulbe Pi=3.14159; //此时并未将Pi放入ROM中
double a=Pi; //此时为Pi分配内存，以后不再分配！
double b=Pi; //没有内存分配 |
| 7 | 提高了效率 | 编译器通常不为普通const常量分配存储空间，而是将它们保存在符号表中，这使得它成为一个编译期间的常量，没有了存储与读内存的操作，使得它的效率也很高。 | |
二、const修饰普通类型的变量
1、const修饰普通类型的变量被赋值后，其值不允许被修改。
const int a = 7;
a = 8; // 错误，a 被编译器认为是一个常量，其值不允许修改。
2、const int a和intconst a两者定义的性质一样。
三、const修饰指针变量
const 修饰指针变量有以下三种情况。
（1）如果const位于 * 的左侧，const 修饰指针指向的内容，则内容为不可变量，简称左定值；
int a = 7;
int b = 8;
const int* c = &a;
*c = b; //错误：指针指向的内容不可修改
c = &b;//正确：指针可以修改
（2）如果const位于*的右侧，const 修饰指针，则指针为不可变量，简称右定向；
int a = 7;
int b = 8;
int* const c = &a;
*c = b; //正确：指针指向的内容可修改
c = &b;//错误：指针为不可变量
（3）const 修饰指针和指针指向的内容，则指针和指针指向的内容都为不可变量。
int a = 7;
int b = 8;
const int* const c = &a;
*c = b;//错误：指针指向的内容不可修改
c = &b;//错误：指针为不可变量
根据上面三种情况总结出便于记忆的话："左定值，右定向，const修饰不变量"。
四、const参数传递和函数返回值。
1、const传递参数
对于 const 修饰函数参数可以分为三种情况：
（1）值传递的 const 修饰传递，传递过来的参数在函数内不可以改变。
#include<iostream>
using namespace std;
void func(const int p)
{
cout << "p = " << p << endl;
//++p;//错误：p值不能修改
}
int main()
{
int a = 10;
int b = 20;
func(a);
func(b);
return 0;
}
（2）当 const 参数为指针时，可以防止指针被意外篡改。
#include<iostream>
using namespace std;
int b = 30;
void func(int* const p)
{
cout << "*p = " << *p << endl;
++*p;
//p = &b;//错误：p不能被修改
}
int main()
{
int a = 10;
func(&a);
cout << "a = " << a << endl;
return 0;
}
（3）自定义类型的参数传递，需要临时对象复制参数，对于临时对象的构造，需要调用构造函数，比较浪费时间，因此我们采取 const 外加引用传递的方法。并且对于一般的 int、double 等内置类型，我们不采用引用的传递方式。同时，传递的对象不能被修改。
/*定义一个学生类，获取学号*/
#include<iostream>
using namespace std;
class Student
{
public:
Student(){}
Student(int num):number(num){}
int get_number()const
{
return number;
}
int set_number(int num);
private:
int number;
};
void get_student_number(const Student& stu)
{
cout<<stu.get_number()<<endl;
//stu.set_number(3333);//对象stu不能被修改
}
int Student::set_number(int num)
{
this->number = num;
return this->number;
}
int main(void)
{
Student RF(1001);
get_student_number(RF);
int rf_num = RF.set_number(2222);
cout << "rf_num = " << rf_num << endl;
return 0;
}
2、const 修饰函数的返回值
Const 修饰返回值分三种情况。
（1）const 修饰内置类型的返回值，修饰与不修饰返回值作用一样,因此这种写法没有意义。
const int func1()
{
return 1;
}
int func2()
{
return 2;
}
（2）const 修饰自定义类型的作为返回值，此时返回的值不能作为左值使用，既不能被赋值，也不能被修改。
（3）const 修饰返回的指针或者引用，是否返回一个指向 const 的指针，取决于我们想让用户干什么。
一般情况下，函数的返回值为某个对象时，如果将其声明为const时，多用于操作符的重载。通常，不建议用const修饰函数的返回值类型为某个对象或对某个对象引用的情况。原因如下：如果返回值为某个对象为const（const A test = A 实例）或某个对象的引用为const（const A& test = A实例） ，则返回值具有const属性，则返回实例只能访问类A中的公有（保护）数据成员和const成员函数，并且不允许对其进行赋值操作，这在一般情况下很少用到。
五、const修饰类成员函数。
const 修饰类成员函数，其目的是防止成员函数修改被调用对象的值，如果我们不想修改一个调用对象的值，所有的成员函数都应当声明为 const 成员函数。
总结
关const一般的考点有两点：
1、const与define的区别
2、const char a,const char* a, char* const a 的含义。
参考文档
https://blog.csdn.net/Eric_Jo/article/details/4138548
https://www.cnblogs.com/Forever-Kenlen-Ja/p/3776991.html
本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)
