从抽象（纯虚拟）类私有继承是否有意义？

Question

假设这个构造

struct InterfaceForFoo
{
    virtual void GetItDone() = 0;
};


class APoliticallyCorrectImplementationOfFooRelatedThings : private InterfaceForFoo
{

  public:
    void GetItDone() { /*do the thing already*/ };   
};

现在，我想知道以这种方式从接口私有继承是否有任何有用的场景。

Answer 1

呵呵，这里的每个人都说“不”。我说“是的，这确实有道理。”

class VirtualBase {
public:
    virtual void vmethod() = 0;
    // If "global" is an instance of Concrete, then you can still access
    // VirtualBase's public members, even though they're private members for Concrete
    static VirtualBase *global;
};

// This can also access all of VirtualBase's public members,
// even if an instance of Concrete is passed in,
void someComplicatedFunction(VirtualBase &obj, ...);

class Concrete : private VirtualBase {
private:
    virtual void vmethod();
public:
    void cmethod() {
        // This assignment can only be done by Concrete or friends of Concrete
        VirtualBase::global = this;
        // This can also only be done by Concrete and friends
        someComplicatedFunction(*this);
    }
};

将继承设置为 private 并不意味着您无法从类外部访问 VirtualBase 的成员，它仅意味着您无法通过引用访问这些成员到具体。但是，Concrete 及其朋友可以将 Concrete 的实例强制转换为 VirtualBase，然后任何人都可以访问公共成员。简单地，

Concrete *obj = new Concrete;
obj->vmethod(); // error, vmethod is private

VirtualBase *obj = VirtualBase::global;
obj->vmethod(); // OK, even if "obj" is really an instance of Concrete

Answer 2

问题是为什么基类只有纯虚方法很重要？

这两件事几乎无关。私有意味着它是类的实现细节，而不是公共接口的一部分，但您可能希望将接口实现为实现细节。假设您编写了一个类，并且决定通过需要您实现接口的库来实现功能。这是一个实现细节，没有必要仅仅因为接口只有纯虚函数而将继承设为公共。

Answer 3

在面向对象方面，抽象类没有这种私有继承的用例。

但是，如果您想强制子类必须派生某些方法，那么您可以使用它。例如：

struct implement_size
{
  virtual size_t size () = 0;
};

class MyVector : private implement_size
{
public:
  size_t size () { ... } // mandatory to implement size()
}

class MyString : private implement_size
{
public:
  size_t size () { ... } // mandatory to implement size()
};

所以，它只是有助于维持个人编码纪律。这个例子传达的信息是，继承不仅仅意味着面向对象的目的。您甚至可以使用继承来停止继承链（类似于Java 最终版）。

Answer 4

呃？不，这绝对没有意义，因为您提供接口的原因是您希望其他人通过该接口使用您的类。如果他们不知道你实施了它，那将如何运作？

#include <vector>

class Fooable{
public:
  virtual void foo() = 0;
};

class DoesFoo
  : private Fooable
{
  void foo();
};

int main(){
  std::vector<Fooable*> vf;
  vf.push_back(new DoesFoo()); // nope, doesn't work
  vf[0]->foo();
}

上面的例子不起作用，因为外界不知道 DoesFoo 是一个 Fooable，因此你不能 new 的实例并将其分配给 Fooable*。

Answer 5

并不真地。如果你需要一个函数，你就实现它。强制一个不能被其他类使用的函数是没有意义的。

我不知道为什么要从接口私有继承；这违背了接口的目的。

如果它不是一个接口，而是一个类，那就有意义了：

class A {
    virtual void foo() = 0;

    void bar() {
        foo();
    }
};

class B : private A {
    virtual void foo() {

    }
};