[C++] 五 const关键字

const关键字

什么是const?
常类型是指使用类型修饰符const说明的类型，常类型的变量或对象的值是不能被更新的。
cons主要的作用?
可以定义const常量，具有不可变性。
便于进行类型检查，使编译器对处理内容有更多了解，消除了一些隐患
可以保护被修饰的东西，防止意外的修改，增强程序的健壮性(如果被修改了编译器就会出现报错)

常成员函数

使用const修饰成员，就是常成员函数
常成员函数有以下特点：
可以调用非const成员变量，但是不能修改其数值
不能调用非const的成员函数

class Test
{
public:
    string s1 = "非const的成员变量";

    void func1()
    {
        cout << "非const的成员函数";
    }

    void func2() const // 常成员函数
    {
        cout << s1 << endl;
//        s1 = "更改"; 错误
//        func1(); 错误
    }

    // 常成员函数调用常成员都可以
    void func3() const
    {
        func2();
    }
};
//如果这个成员函数可以被const修饰，尽量使用const进行修饰

常指针

const int *A; //const修饰指向的对象，A可变，A指向的对象不可变
int const *A; //const修饰指向的对象，A可变，A指向的对象不可变
int *const A; //const修饰指针A， A不可变，A指向的对象可变
const int *const A;//指针A和A指向的对象都不可变

修饰常引用 使用const修饰符也可以说明引用，被说明的引用为常引用，该引用所引用的对象不能被更新。其定义格式如下：
const double & v;

const double & v;

修饰函数的常参数 const修饰符也可以修饰函数的传递参数，格式如下：

void Fun(const int Var);

常量对象

const修饰的对象就是常量对象
常量对象有以下特点：
常量对象中任何属性都不能被修改
常量对象不能调用非const的成员函数

class Test
{
public:
    string s1 = "你好";

    void func1()
    {
        cout << "非const的成员函数" << endl;
    }

    void func2() const;
};

void Test::func2() const
{
    cout << "const的成员函数" << endl;
}

int main()
{
    // 常量对象
    Test const t1;
    const Test t2;
    cout << t1.s1 << endl;
//    t1.s1 = "更改"; 错误
//    t1.func1(); 错误
    t1.func2();

    return 0;
}

常成员变量

使用const修饰的成员变量，就是常成员变量
常成员变量的数值在程序运行期间不可变
常成员变量的赋值操作可以直接在声明后赋值，也可以通过构造出始化列表赋值，其他方式无法赋值

class Test
{
public:
    const int a = 1;

    Test():a(2){} // 构造初始化列表在编译期间决定了a从1到2

    Test(int a):a(a){}
};

int main()
{
    Test t;
    cout << t.a << endl; // 2
//    t.a++; 错误

    Test t2(3);
    cout << t2.a << endl; // 3

    return 0;
}

const修饰局部变量

与const修饰引用参数类似，表示局部变量的值不可变

class Test
{
public:
    void func(const int a)
    {
        const int b = a+1;
//        a++; 错误
//        b++; 错误
        cout << a << endl;
        cout << b << endl;
    }
};

int main()
{
    Test t;
    t.func(45);

    return 0;
}

const修饰静态成员变量

const修饰静态成员与非静态成员的用法基本一致，比较特殊的在于静态成员变量被const修饰后，可以直接在类内赋值初始化

class Test
{
public:
    const static int a = 1;
};