调用重载函数-with继承的类作为参数-是不明确的

Question

这个标题已经被多次使用了，但是在搜索了5-6个例子之后，我找不到任何与我的问题相匹配的东西：

我有一个简单的继承实践。

类A是一个基类，类B & C继承它：

class A {

};

class B : public A { public:    int i; };

class C : public A { public:    int j; };

以及包含重载函数的类P如下所示：

class P
{
public:
    void change(B *b)
    {
        b->i =1;
    }

    void change(C *c)
    {
        c->j =1;
    }
};

当我使用如下函数时：

int main()
{
    A *b = new B();
    A *c = new C();
    P p;
    p.change(b);
    p.change(c);
    return 0;
}

它错误地说：

inherit2.cpp: In function ‘int main()’:
inherit2.cpp:37:12: error: call of overloaded ‘change(A*&)’ is ambiguous
inherit2.cpp:37:12: note: candidates are:
inherit2.cpp:21:7: note: void P::change(B*) <near match>
inherit2.cpp:21:7: note:   no known conversion for argument 1 from ‘A*’ to ‘B*’
inherit2.cpp:26:7: note: void P::change(C*) <near match>
inherit2.cpp:26:7: note:   no known conversion for argument 1 from ‘A*’ to ‘C*’
inherit2.cpp:38:12: error: call of overloaded ‘change(A*&)’ is ambiguous
inherit2.cpp:38:12: note: candidates are:
inherit2.cpp:21:7: note: void P::change(B*) <near match>
inherit2.cpp:21:7: note:   no known conversion for argument 1 from ‘A*’ to ‘B*’
inherit2.cpp:26:7: note: void P::change(C*) <near match>
inherit2.cpp:26:7: note:   no known conversion for argument 1 from ‘A*’ to ‘C*’

如果你能帮我解决这个问题，我将不胜感激。拉赫曼

Answer 1

Polymorphism is one answer

class A
{
public:
    virtual void set() = 0;
};


class B : public A
{
public:
    virtual void set() { i = 1; }
private:
    int i;
};

class C : public A
{
public:
    virtual void set() { j = 1; }
private:
    int j;
};

class P
{
public:
    void change(A *a)
    {
        a->set();
    }
};

int main()
{
    A *b = new B();
    A *c = new C();
    P p;
    p.change(b);
    p.change(c);
    return 0;
}

有了多态性，就不需要多个change方法。

Answer 2

你可以：

• 通过为i和j添加虚拟设置器函数来使用多态性： 类A{ public:虚拟空集( int )= 0；}；类B: public A{ public: void set( int值){i= value；} private: int i；}；类P{ public：(A* obj) { obj->set(1)；}；int main() {A *b =新B()；A *c =新C()；p；p.change(b)；p.change(c)；返回0}；
• 在传递指针之前对指针进行大小写： A *b =新B()；A *c =新C()；P p；p.change(static_cast(b))；p.change(static_cast(c))；
• 将变量放入基类(并去掉两个change()函数)： A类{ public: int i；}；B类: public A {}；C类: public A {}；

Answer 3

我会调整你的班级等级以使用多态：

class A
{
public:
    virtual void SetVariable(const int value) = 0;
};

class B : public A
{
public:
    virtual void SetVariable(const int value) override { i = value; }
    int i;
};

class C : public A
{
public:
    virtual void SetVariable(const int value) override { j = value; }
    int j;
};

class P
{
public:
    void change(A *a)
    {
        a->SetVariable(1);
    }
};

通过这种方式，您可以使用指向基类(A)的指针，而无需知道它们是哪种特定的派生类型。