c++中const限定符的使用

指针

1. const T* v，此时指针指向内存的值无法被修改

int a = 10;
const int* a_ptr = &a;

int b = 20;
*a_ptr = 20; // 错误
a_ptr = &b; // 正确
std::cout << *a_ptr << std::endl; // 输出20

2. T* const v, 此时指针指向的内存地址不可以被修改

int a = 10;
int* const a_ptr = &a;

int b = 20;
*a_ptr = 20; // 正确
a_ptr = &b; // 错误
std::cout << *a_ptr << std::endl; // 输出20

3. const T* const c, 此时既无法修改指针指向，也无法修改指针指向内存的值

int a = 10;
const int* const a_ptr = &a;

int b = 20;
*a_ptr = 20; // 错误
a_ptr = &b; // 错误

成员函数

1. const T& class::fun(), 此时不允许修改fun函数的返回值

class A
{
public:

    const auto& get_aaa() { return aaa_; } // 若函数在头文件中实现，则可以使用auto，否则只能
                                           // 使用const int& get_aaa();
private:
    int aaa_ = 0;
};

int main()
{
    A a;
    auto& aaa = a.get_aaa(); // 编译错误，使用引用接受常量引用非法。
    const auto& aaa = a.get_aaa(); // 正确
    return 0;
}

2. T class::fun() const, fun函数中不允许修改类成员变量，不允许调用非const函数，允许const修饰的对象调用的成员函数

class A
{
public:
    void fun();
    void fun1() const;
private:
    int aaa_ = 0;
};

void A::fun()
{
    aaa_ = 10;
    fun1();
}

void A::fun1()
{
    aaa_ = 10; // 错误
    fun(); // 错误
}

int main ()
{
    const A a;
    a.fun(); // 错误
    a.fun1(); // 正确
    return 0;
}

3. const T& class::fun() const, 综合上面两种情况，既不可以修改函数返回值，又不可以在函数中修改成员变量