Question

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

当我们宣布某个课时，我们这样做是正常的：

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

但是如果你希望你的类支持const对象，你将使用const限定符重载成员函数：

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;
};

现在让我们看看为什么我们希望我们的班级有4个重载：

// 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

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

易失性并未广泛使用，当它变为基本类型时。但绝不是对象，所以你永远不需要覆盖volatile成员函数。
const应添加到成员函数中，而不是考虑const客户端代码是否需要它，而是考虑成员函数的操作是否在概念上是恒定的。这称为 const correctness ：

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

湾然后，问问自己这个函数是否会改变对象的可观察状态。如果是，那么该函数不应该是常数。如果没有，则将其声明为常量。

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

请注意，我谈到了对象的 observable state ，而不是成员变量的实际内容：这是一个实现细节。

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

1 个答案: