类4(可变数据成员/基于const的重载)

可变数据成员：

有时我们希望能修改某个类的数据成员，即使是在一个 const 成员函数内。可以通过在变量的声明中加入 mutable 关键字来声明一个可变数据成员。mutable 是为突破 const 的限制而设置的。被 mutable 修饰的变量将永远处于可变状态中，即使是在一个 const 成员函数中：

 #include <iostream>
 using namespace std;

 class gel{
 private:
     mutable size_t access_ctr;

 public:
     gel() = default;
     gel(const int &x):access_ctr(x){}
     // ~gel();

     void out_put() const{
         cout << access_ctr << endl;
     }

     void some_member(void) const{
         ++access_ctr;
     }
 };

 int main(void){
     const gel x();
     x.out_put();//输出1
     x.some_member();
     x.out_put();//输出2
     x.some_member();
     x.out_put();//输出3
     return ;
 }

关于 mutable 关键字存在的必要性：https://www.zhihu.com/question/64969053/answer/226383958

基于 const 的重载：

 #include <iostream>
 using namespace std;

 class gel{
 private:
     int x;

 public:
     gel() = default;
     gel(int val): x(val){}

     const gel &display(std::ostream &os) const{
         std::cout << x;
         return *this;
     }

     gel &count(void){
         x++;
         return *this;
     }
 };

 int main(void){
     gel x();
     x.display(cout);
     x.count();
     // x.display(cout).count();//错误：display 返回的是一个 const 对象，而 count 不是常量函数
     return ;
 }

一般来说像 x.display(cout); 与 x.count(); 应该是要可以写成 x.display(cout).count()；的形式的。但这个代码中 display 返回的是一个 const 对象，所以后者显然是错误的。这是我们代码写的不合理，应该尽量避免写出这样的代码。我们可以通过重载解决这个问题：

 #include <iostream>
 using namespace std;

 class gel{
 private:
     int x;

 public:
     gel() = default;
     gel(int val): x(val){}

     gel &display(std::ostream &os){
         do_display(os);
         // os << x;//在代码比较短的时候这样写也一样，不过要是代码量大的话显然要多写不少代码
         return *this;
     }

     const gel &display(std::ostream &os) const{
         do_display(os);
         // os << x;
         return *this;
     }

     gel &count(void){
         x++;
         return *this;
     }

 private:
     void do_display(std::ostream &os) const{
         os << x;
     }
 };

 int main(void){
     gel x();
     x.display(cout).count();
     return ;
 }

这里我们通过调用 display 的对象是否为常量来决定调用哪个 display 函数。需要注意的是这里是通过底层 const 来区分重载函数的(形参会忽略顶层 const)，若调用 display 的对象是 const，那么隐式传递的 this 指针具有底层 const，反之则没有。

调用 display 的是非常量的话，display 返回的也是一个非常量对象，此时 x.display(cout).count()；顺利执行；

调用 display 的是常量的话， display 返回的也是一个常量对象，此时 x.display(cout).count()；报错。

显然，这个代码中的 x.display(cout).count()；与 x.display(cout)；x.count()；是完全等价的。