关键字const

修饰普通变量

变量是常量，不可变(两种写法一样)
const int data=100;
int const data=100;
//data=200;//error

修饰指针

指针是常量，不可变
int* cosnt ptr;
指针指向的内容是常量，不可变
const int* ptr;
指针和指针指向的内容都是常量，不可变
const int* const ptr;

void TestConstPtr() {
    int data_1=100;
    int data_2=200;

    int* const ptr_1=&data_1;
    //ptr=&data_2;//error
    *ptr_1=300;
    
    const int* ptr_2=&data_1;
    ptr_2=&data_2;
    //*ptr_2=300;//error

    const int* const ptr_3=&data_1;
    //ptr_3=&data_2;//error
    //*ptr_3=100;//error
}

const修饰类变量，类函数

1 const类成员变量只能在初始化列表中初始化
2 const类成员函数，不能修改任何类成员变量。只能调用const的类成员函数，不能调用非const的类成员函数

class A
{
    int data_1;
    const int data_2;
public:
     A()
     :data_2{200}//在初始化列表中进行const变量初始化
     {
        data_1=100;
        //data_2=200;//error：const变量只能在初始化列表中初始化
     }

    ~ A() {
        std::cout<<__FUNCTION__<<std::endl;
    }

    void show() {
        std::cout<<__FUNCTION__<<":";
        func();
        func_const();
    }

    void show_const() const {
        std::cout<<__FUNCTION__<<":";
        //func();//eroor：const函数只能调用const函数，不能调用非const函数
        func_const();
        //data_1=300;//error:不能修改类变量
    }

private:
    void func() {
        std::cout<<__FUNCTION__<<std::endl;
    }

    void func_const() const {
        std::cout<<__FUNCTION__<<std::endl;
    }
    
};

const修饰类对象，类对象指针，类对象引用

const修饰的类对象、类对象指针、类对象引用只能访问类的const成员函数，不能访问非const成员函数

void TestConstClass() {
    const A ac;
    //ac.show();//error
    ac.show_const();

    const A* ptr_Ac=new A();
    //ptr_Ac->show();//error
    ptr_Ac->show_const();

    const A& ac_1=ac;
    //ac_1.show();//error
    ac_1.show_const();
}