C++ возможно ли, чтобы класс расширил один класс и одновременно реализовал интерфейс?

Question

Coluld вы предоставляете простой пример кода? (извините 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

Не уверен, что вы спрашиваете:

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 3

В 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 4

вопрос, как указано,

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

Виртуальное наследование гарантирует, что существует только один суб-объект типа TalkerInterface в MyClass инстанции. Это имеет некоторые противоречивые последствия. Один из них заключается в том, что «наследование в реализации» работает, а другое заключается в том, что построение под-объекта базового класса происходит в каждом конструкторе MyClass и, как правило, в самом производном классе. .

Приветствия & НТН,

Answer 5

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