设计API时如何使用const和volatile设计重载成员函数？

Question

假设您正在编写一个将分发给其他程序的小型库或API，这意味着您永远都不知道其他程序员将如何创建对象：这样的对象是const，volatile，const volatile还是仅仅是一个普通对象。

通常，当我们声明某个类时，我们这样做：

class A // THIS CLASS DOES NOT SUPPORT ANYTHING
{
public:
    int get() { return x; }
private:
    int x;
};

但是，如果您希望您的类支持const对象，则可以使用const qualifierator重载成员函数：

class B // THIS CLASS SUPPORTS CONST OBJECTS
{
public:
    int get() { return x; }
    int get() const { return x; }
private:
    mutable int x;
};

也许我们还想支持volatile但不支持const：

class C // THIS CLASS SUPPORTS VOLATILE OBJECTS
{
public:
    int get() { return x; }
    int get() volatile { return x; }
private:
    int x;
};

但是，如果用户将使用const或volatile的对象，或者如果用户将同时使用volatile和const的对象怎么办？ 那么我们也应该为此添加支持！

class D // THIS CLASS SUPPORTS CONST, VOLATILE AND CONST VOLATILE OBJECTS
{
public:
    int get() { return x; }
    int get() const { return x; }
    int get() volatile { return x; }
    int get() const volatile { return x; }
private:
    mutable int x;
};

现在让我们看看为什么我们要让我们的类有这四个重载：

// EXAMPLE
int main()
{
    // figure 1
    const A a ;
    a.get(); // ERROR

    // figure 2
    volatile B b;
    b.get(); // ERROR

    // figure 3
    const volatile C c;
    c.get(); // ERROR

    // figure 4 where we finaly created a super class capable of anything!!
    const volatile D d;
    d.get(); // NOW IS OK!

    cin.ignore();
    return 0;
}

在最后一个示例中（图4），我们可以肯定我们的类能够被任何类型的实例化，这意味着其他程序员在创建您的volatile，const或volatile const对象时将不会遇到任何问题！

我的问题是：覆盖每种方法四次是否是一种好的设计实践？ 如果不是，为什么不呢？

同样，如果我们的类有20个方法，那么当您全部重载它们时，它将总共有80个方法！

编辑：

现实世界中的API类会这样做吗？ 如果没有，那么如果我们有这种需要，我们将如何创建该类的volatile或const volatile对象。

Answer 1

我的观点是，在现实世界中：

1. 易用性并未得到广泛使用，当它被使用时，总是会修改基本类型。 但是绝不会对象，因此您无需覆盖易失性成员函数。

2. const应该添加到成员函数中，而不是在考虑const客户端代码是否需要它，而应该考虑成员函数所做的操作在概念上是否恒定。 这就是所谓的const正确性 ：

   一种。 首先，函数应该只做一件事。 也许是一件复杂的事情，但可以描述为一个单一的概念。

   b。 然后，问问自己函数是否确实改变了对象的可观察状态 。 如果是这样，则该函数不应为常数。 如果不是，则将其声明为常量。

当客户端代码想要使用您的类时，当不允许修改对象的状态时，它将具有const引用，并且所有这些都可以正常工作。

请注意，我讲的是对象的可观察状态 ，而不是成员变量的实际内容：这是一个实现细节。