Question

我有以下课程：

#include <iostream>

using namespace std;

class M
{
};

class N:public M
{
};

class A
{
    public:
        virtual void f(M& m)=0;
};

class B:public A
{
    public:
        void f(M& m){cout<<"using M version"<<endl;}
        void f(N& n){cout<<"using N version"<<endl;}
};

以及以下实施：

int main()
{
    N n;
    A &o = *new B();
    o.f(n);
    //o.f(static_cast<N&>(n));
}

基本上我想在调用“o.f（n）”时实现“void f（N＆amp;）”而不是“void f（M＆amp;）”，但不知道如何实现它。

Answer 1

您应该使用虚拟功能。这就是多态性的用途：在运行时确定对象的类型。通过将f()作为虚函数来修改代码如下。

#include <iostream>

using namespace std;

class A
{
    private:
        int a;
    public:
        A():a(1){}
        void show(){cout<<a<<endl;}
        virtual void f(A & a) {a.show();}
};

class B:public A
{
    private:
        int b;
    public:
        B():b(2){}
        void show(){cout<<b<<endl;}
        virtual void f(B & a) {a.show();}
};

int main()
{
    A * pa = new A();
    f(*pa);
    pa = new B();
    f(*pa);
}

Answer 2

对于您描述的特定行为，您可以使用static_cast：

f(static_cast<B&>(*pa));

但是每个人都是对的，你最好通过使show()方法虚拟来使用真正的多态性：

#include <iostream>

using namespace std;

class A
{
    private:
        int a;
    public:
        A():a(1){}
        virtual void show(){cout<<a<<endl;}
};

class B:public A
{                                                                                                                                                                                     
    private:
        int b;
    public:
        B():b(2){}
        void show(){cout<<b<<endl;}
};

void f(A & a) {a.show();}

int main()
{
    A * pa = new A();
    f(*pa);
    pa = new B();
    f(*pa);
}

Answer 3

指向B并致电f(*pb)。或f(*static_cast<B*>(pa));。

虽然我认为你真正想要的是让你的方法变得虚拟。

virtual void show(){cout<<a<<endl;}

它仍然会调用第一个f()，但会调用show()的{{1}}方法。

以下示例可以帮助您更好地处理操作中的不同概念：

使用以下输出

#include <iostream>

using namespace std;

class A
{
public:
    void show(){cout<<"show: A"<<endl;}
    virtual void show_virtual(){cout << "show_virtual: A" << endl; }
};

class B:public A
{
public:
    void show(){cout<<"show: B"<<endl;}
    virtual void show_virtual(){cout << "show_virtual: B" << endl; }
};

void f(A & a)
{
    cout << "f(A&)" << endl;
    a.show();
    a.show_virtual();
}
void f(B & b)
{
    cout << "f(B&)" << endl;
    b.show();
    b.show_virtual();
}

int main()
{
    A * pa = new A();
    B * pb = new B();
    A * pb_a = pb;

    f(*pa);
    cout << endl;
    f(*pb);
    cout << endl;
    f(*pb_a);
}

Answer 4

基本上我想要＆＃34; void f（N＆amp;）＆＃34;实施而不是＆＃34;无效 F（M＆安培;）＆＃34;在调用＆＃34; o.f（n）＆＃34;时，但不知道如何实现它。

你不能打电话给＃34; void f（N＆amp;）＆＃34;因为班级A中没有这样的方法。

解决方案：在void f(N&)中声明class A：

class A
{
    public:
        virtual void f(M& m)=0;
        virtual void f(N& n)=0;
}

函数重载与基类和派生类引用

4 个答案: