03-4 常函数和常对象

1. 常函数：
   • 成员函数后加const后我们称这个函数为：常函数。
   • 常函数内不可以修改成员属性
   • 如果在成员属性声明的时候加上关键字mutable，在常函数中可以修改
2. 常对象：
   • 声明对象前加上const，则这个对象是常对象。
   • 常对象只能调用常函数。

我们来试一试：

1. 常函数：

   • 成员函数后加const：常函数

     void showPerson() const
     {
     cout << m_A << endl;
     }

     void showPerson() const就表示这个函数是一个常函数。

   • 常函数不可以修改成员属性

     普通成员函数可以修改成员属性的数据

     void setPerson()
     {
     m_A = 100;
     }

     但是常函数就会报错：

     void showPerson() const
     {
     //m_A = 100;
     cout << m_A << endl;
     }

     如果将m_A = 100;注释打开，那么报错如下：

     表达式必须是可修改的左值

     这和this指针有关系，比如所下面这一段代码：

     void setPerson()
     {
     m_A = 100;
     }

     在编译器看来就是这样：

     void setPerson()
     {
     this->m_A = 100;
     }

     this指针本质是一个指针常量，指针常量的特点是指针的指向不可以被修改，对于我们这个例子来说，this指针相当于就是class Person* const this。

     而如果我们不想修改指针指向的数据值，那就是const class Person* const this。所以void showPerson() const加上const后，就会限制为const class Person* const this，指针指向的数值也不可以改。

     在成员函数的后面加上const，本质是修饰this指向，让指针指向的数据值也不可以修改。

   • 如果在成员属性声明的时候加上关键字mutable，在常函数中可以修改。

     class Person
     {
     public:
     int m_A;
     mutable int m_B;
     void showPerson() const
     {
         m_B = 100;
         cout << m_B << endl;
     }
     };

     在这里，mutable修饰了int m_B，所以在常函数中，也可以进行修改。

2. 常对象：

   • 声明对象前加上const，则这个对象是常对象。

     #include 
     using namespace std;
     class Person
     {
     public:
     int m_A;
     mutable int m_B;
     void showPerson() const
     {
         m_B = 100;
         cout << m_A << endl;
     }
     };
     void main()
     {
     const class Person p;
     }

     在这里，我们在main函数中创建了一个常变量p。

     常对象也是不允许修改数值的。比如：

     void main()
     {
     const class Person p;
     //p.m_A = 100;
     p.m_B = 100;
     }

     这还是因为this指针。常对象前有const修饰，所以常对象的this指针也被修饰为不可以修改数据、不可以修改指向的了，所以，常对象的属性也不可以改。

     但是如果属性有mutable，这个属性就可以被修改（理由和常函数一样），所以m_B可以修改。

   • 常对象只能调用常函数。

     #include 
     using namespace std;
     class Person
     {
     public:
     int m_A;
     mutable int m_B;
     void constPerson() const
     {
         cout << "这是常函数的调用" << endl;
     }
     void nPerson()
     {
         cout << "这是普通的成员函数的调用" << endl;
     }
     };
     void main()
     {
     const class Person p;
     class Person p2;
     p.constPerson();
     //p.nPerson();
     p2.constPerson();
     p2.nPerson();
     }

     在这里我们创建了常对象p和普通对象p2。普通对象p2可以调用常函数和普通函数。但是常对象p只能调用常函数。

     如果我们将p.nPerson();打开，则会出现报错，报错理由如下：

     函数 "Person::nPerson" 不兼容的类型限定符

     原因是，普通函数可以修改属性的数值，但是常对象不可以修改属性。虽然我们上面的普通函数nPerson没有修改属性数值的操作，但是可以添加一行m_A = 100;。所以常对象只能调用常函数。

总结：

1. 常函数：

   • 成员函数后加const
   • 常函数内不可以修改成员属性
   • 属性声明的时候加上关键字mutable，在常函数中可以修改

2. 常对象：

   • 声明对象前加上const
   • 常对象只能调用常函数。
   • 属性声明的时候加上关键字mutable，则这个成员属性可以修改
3. this指针的本质：
   • this指针本质是一个指针常量
   • 添加const的常函数和常对象相当于是禁止修改指针指向的数据值。