类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(1);
    x.out_put();//输出1
    x.some_member();
    x.out_put();//输出2
    x.some_member();
    x.out_put();//输出3
    return 0;
}

关于 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(0);
    x.display(cout);
    x.count();
    // x.display(cout).count();//错误：display 返回的是一个 const 对象，而 count 不是常量函数
    return 0;
}

一般来说像 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(0);
    x.display(cout).count();
    return 0;
}

这里我们通过调用 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()；是完全等价的。