C++是否有可能使一个类扩展一个类并同时成为一个接口的实现？

Question

您能提供一个简单的代码示例吗？ （对不起，C++ nube）以及如何从您正在扩展的类中调用函数？

Answer 1

一个有用的例子：:-)

class CImplementation
{
public:
void doFoo();
};

void CImplementation::doFoo()
{
//implementation
}

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

class DerivedFromImplementationAndInterface : public CImplementation, public IInterface
{
virtual void foo();
};

void DerivedFromImplementationAndInterface::foo()
{
doFoo();
}


//possible usage:
void method(IInterface& aInterface)
{
aInterface.foo();
}

void test()
{
IInterface* d = new DerivedFromImplementationAndInterface;
method(*d);
}

Answer 2

在C++中，你可以扩展多个类，这称为多重继承。这很可能就是您正在寻找的。请阅读一本关于多重继承和 C++ 的好书（快速介绍：http://publib.boulder.ibm.com/infocenter/comphelp/v8v101/index.jsp?topic=%2Fcom.ibm.xlcpp8a.doc% 2Flanguage%2Fref%2Fcplr134.htm），因为有很多陷阱和细节需要注意。

多重继承的示例：

class A { ... };
class B { ... };
class C: public A, public B {};  // C inherits from A and B.

Answer 3

C++ 没有显式地具有接口，相当于 Java 中的接口通常使用仅具有纯虚函数（加上构造函数、析构函数、复制赋值）的类来实现：

#include <iostream>

// interface
class Fooable {
  public:
    virtual int foo() = 0;
    virtual ~Fooable() {}
};

// base class
class Base {
  public:
    void non_virtual_function() { std::cout << "Base::non_virtual_function\n"; }
    virtual void virtual_function() { std::cout << "Base::virtual_function\n"; }
};

// derived class, inherits from both Base "class" and Fooable "interface"
class Derived: public Base, public Fooable {
  public:
    virtual int foo() {
      // call base class function
      Base::non_virtual_function();
      // virtual call to function defined in base class, overridden here
      virtual_function();
    }
    virtual void virtual_function() {
        // call base class implementation of virtual function directly (rare)
        Base::virtual_function();
        std::cout << "Derived::virtual_function\n";
    }
    void non_virtual_function() {
        // not called
        std::cout << "Derived::non_virtual_function\n";
    }
};

int main() {
    Derived d;
    d.foo();
}

Answer 4

不确定您在问什么：

class A
{
  public:
    void method();
};

class B
{
  public:
    void method();
};

class C : public A, public B
{
  public:
    void callingMethod();
};

void C::callingMethod()
{
  // Here you can just call A::method() or B::method() directly.
  A::method();
  B::method();
}

请注意，多重继承可能会导致真正难以解决的问题，我建议仅在必要时使用它。

Answer 5

如所提出的问题，

C++ 是否可以让一个类扩展一个类并实现另一个类？

没有多大意义。答案就是“是”。您可以从任意数量的类派生：C++ 完全支持多重继承。

因此，鉴于所提出的问题并没有真正的意义，您至少有可能想要问

C++ 是否可以让一个类扩展一个类，从而实现另一个类？

这个问题的答案也是肯定的，但这并不是微不足道的。它涉及虚拟继承。这是相当棘手的。

下面是一个示例：

#include <iostream>

void say( char const s[] ) { std::cout << s << std::endl; }

class TalkerInterface
{
public:
    virtual void saySomething() const = 0;
};

class TalkerImpl
    : public virtual TalkerInterface
{
public:
    void saySomething() const
    {
        say( "TalkerImpl!" );
    }
};

class MyAbstractClass
    : public virtual TalkerInterface
{
public:
    void foo() const { saySomething(); }
};

class MyClass
    : public MyAbstractClass
    , public TalkerImpl
{};

int main()
{
    MyClass().foo();
}

虚拟继承确保在 MyClass 实例中只有 一个 类型为 TalkerInterface 的子对象。这会产生一些违反直觉的后果。一是“在实现中继承”有效，二是基类子对象的构造发生在每个 MyClass 构造函数中，更一般地发生在最派生的类中。

干杯&呵呵，