C++_const

1.const修饰变量为常量

//初始化后不可改变
const int a  = 5;

1.1const修饰指针

//指针为常量，不可改变
int *const a;
//不能通过指针修改其指向内容
const int * b;

2.const修饰函数参数

2.1值传递const

void test(const int a)
{
    //值传递，形参会产生实参拷贝的副本，const修饰不允许修改形参值
    //但对实参并无影响
    cout << a << endl;
    //a = 5;
}
int main()
{
    int a = 6;
    test(a);
}

2.2函数参数为指针类型

2.2.1修饰指针指向的内容，不可通过其指针修改内容

void test_1(const int *a)
{
    cout << *a << endl;
    //const 修饰指针指向的内容，则不能通过该指针修改指向内容
    //*a = 5;  error 
}
int main()
{
    int a = 6;
    test_1(&a);    
}

2.2.2修饰指针本身，指针指向的内容可以修改，本身指向不可修改

void test_3(int* const a)
{
    //int *const  、参数指针本身为常量不可变
    //不能改变其指向，但可以改变其内容
    *a = 7;
    cout << a << endl;
    int b = 5;
    //a = &b;    error  //指针指向不可被改变
}
int main()
{
    int a = 6;
    test_3(&a);
    cout << a << endl;    // a=7 修改指针指向的内容
}

 2.3 const修饰类型为引用类型，保护实参不被修改，提升效率

void test_2(const int &a)
{
    //防止实参被修改
    //引用参数在函数内为常量不可修改
    //a = 5;
}
int main()
{
    int a = 6;
    test_2(a);    
}

3. const 修饰类对象/修饰类成员函数

const 修饰类成员函数，防止成员函数修改对象值

3.1类成员函数：

类成员函数不能修改对象的成员变量，除成员变量被mutable修饰

不能调用非const成员函数

3.2 const修饰类对象

const修饰类对象表示该对象为常量对象，任何成员不能被修改

不能调用非const 成员函数

#include <iostream>
using namespace std;
class A
{
public:
    const int a;  //const 修饰类的成员函数，成员变量，不能被修改，只能在初始化列表赋值
    int b;
　　 mutable int c;
    A(int x): a(x) {};
    void test() const
    {
        cout << a << endl;
　　　　　c = 6;// 成员变量被mutable修饰可改变
        b = 5; //常成员函数，不能改变对象的成员变量
        print(); //不能调用类中非const 成员函数
    }
    void print()
    {
        cout << "log" << endl;
    }
};
int main()
{
    int a = 6;
    const A b(5);
    //b.print();
    //const 修饰的对象，不能调用非const成员函数，非const成员函数修改变量企图
}

4.const 指向指针常量：const double *p  （底层const）

可以指向常量或非常量，仅不能通过该指针修改值

常量指针：int *const p1 (顶层const)

指针本身是一个常量，不能改变指向

顶层const 拷贝不受影响/底层const拷入拷出必须有相同的资格

#include <iostream>
using namespace std;

int main()
{
    const int i = 0;
    //底层const 拷入拷出必须有相同的底层资格
    
    //int* p2 = &i; error    //非常量 =常量  error
    const int* p2 = &i;      //常量 = 常量
    //引用
    //int& r = i; error
    const int& r = i;
    //非常量可以转化为常量
    int j = 0;
    const int* p2 = &j;     //常量 = 非常量
    const int& r = j;
}