多态性>错误：'no known conversion from derived class to base class'

Polymorphism->error: 'no known conversion from derived class to base class'

本文关键字：class from derived to base conversion no gt 错误 多态性 known      更新时间：2023-10-16

我怎么可能做到这一点：

class Base
{
public:
    int a, b, c;
    void function();
    ...
};
class Derived1 : 
    private Base
{
public:
    int d, e, f;
    ...
};
class Derived2 :
    private Base
{
public:
    void addObject(const Base* obj);
    ...
};

请注意，我将其继承为私有

然后我想做类似：

Base* d1 = new Derived1();
Base* d2 = new Derived2();
d2->addObject(d1);

这是我从编译器那里得到的相关问题：

C:testtest.cpp||In function 'void init()':|
C:testtest.cpp|423|error: no matching function for call to 'Derived2::addObject(const Base*)'|
C:testtest.cpp|423|note: candidate is:|
C:testtest.h|29|note: void Derived2::addObject(const Base*)|
C:testtest.h|29|note:   no known conversion for argument 1 from 'Derived1 {aka ... }' to 'const Base* {aka ... }'|
||=== Build finished: 1 errors, 0 warnings (0 minutes, 9 seconds) ===|

我想通过一些派生类将Base继承为私有的原因是为了在公共范围中隐藏一些Base的成员/函数。

我不想直接访问公共作用域中的某些Base::functions()，但在其他情况下，我使用了Derived::function()来操作其数据成员，并让派生类决定它将执行什么操作。

然而，我可以考虑覆盖基类中的每个函数，我不想在公共范围内直接修改这些函数，但它不灵活，在我的情况下太多了。

我的意思是：

class Base
{
public:
    //I must think in advance deciding whether if it'll be virtual or not.
    [virtual] void f1(int);
    [virtual] void f2(int);
    [virtual] void f3(int);
    //and many more...
};
class Derivedn :
    private Base
{
public:
    //hmm, I should not neglect to override certain base' member functions
    //that I don't want to access in public scope.
    void f1(int);
};

我想避免这种情况，但是。。。

有没有其他方法可以做到，类似于这个方法，而不覆盖每个Base::function()？

这不起作用的原因是私下继承并不构成"是"关系。事实上，与继承相比，它更接近于组合，因为派生类在不获取其接口的情况下获取了基的实现。

我希望某些派生类将Base作为私有继承的原因是为了在公共范围中隐藏某些Base的成员/函数。

这是私人继承的错误理由。以下是一些很好的答案来回答你何时应该私下继承的问题。

有没有其他方法可以做到，类似于这个方法，而不覆盖每个Base:：function（）？

不需要覆盖Base的每一个函数，除非它们是纯虚拟（也称为"抽象"）函数。基类可以为其虚拟函数提供空的实现，这样派生类就可以决定提供哪些功能。

我认为您的代码应该是：

d2.addObject(&d1); // Note the "&"

正如编译器所说，不可能从Derived1的实例转换为指向Base实例的常量指针。

不确定你想要什么，但多态性确实做到了这一点，允许你覆盖派生类中的基函数：

class Base
{
public:
    int a, b, c;
    virtual void function();
    ^^^^^^^
    ...
};
class Derived1 : 
    public Base
{
public:
    int d, e, f;
    virtual void function(); // do derived version of Base::function
};

现在您可以从基本对象

访问函数的派生版本
相关文章：