4

假设这个构造

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


class APoliticallyCorrectImplementationOfFooRelatedThings : private InterfaceForFoo
{

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

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

4

5 回答 5

6

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

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。但是，它的朋友可以投射toConcrete的实例，然后任何人都可以访问公共成员。简单地，ConcreteVirtualBase

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
于 2011-07-10T18:16:35.367 回答
2

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

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

于 2011-07-10T21:09:42.123 回答
1

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

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

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 final）。

于 2011-07-10T17:59:13.623 回答
-1

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

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

如果它不是一个接口，而是一个类，那是有道理的：

class A {
    virtual void foo() = 0;

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

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

    }
};
于 2011-07-10T17:52:44.797 回答
-1

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

#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是 a Fooable，因此您不能new将其实例化并将其分配给 a Fooable*。

于 2011-07-10T17:56:24.760 回答