C++ const用法详解

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