指针
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, 综合上面两种情况,既不可以修改函数返回值,又不可以在函数中修改成员变量