运行时多态性究竟意味着什么？

我对运行时多态性略有困惑。纠正我，如果我错了，但据我所知，运行时多态性意味着函数定义将在运行时解决。运行时多态性究竟意味着什么？

拿这个例子：

class a 
{ 
a(); 
~a(); 
void baseclass(); 
} 

class b: class a 
{ 
b(); 
~b(); 
void derivedclass1(); 
} 

class c: class a 
{ 
c(); 
~c(); 
void derivedclass2(); 
}

调用方法：

b derived1; 
a *baseptr = &derived1; //here base pointer knows that i'm pointing to derived class b. 
baseptr->derivedclass1();

在上面的调用方法，基类的都知道，它的指向派生类B.

那么歧义存在哪里呢？

在什么情况下函数定义会在运行时被解析？

来源

2010-08-11 Naruto

含糊不清？您发布的代码不会显示任何形式的多态。 – 2010-08-11 09:49:05

事实上，代码不会编译，因为您不能使用指向'a'的指针调用'derivedclass1'（除非您明确地首先将其转换为'b'）。 – sepp2k 2010-08-11 09:50:39

提供的示例中不存在歧义。

如果基类与派生类具有相同的函数名称，并且按照您指定的方式调用，它将调用基类的函数而不是派生类。

在这种情况下，您可以使用virtual关键字来确保函数从当前被指向的对象中被调用。它在运行时间内解决。

Here你可以找到更多的解释..

来源

2010-08-11 09:56:18 liaK

你的链接似乎不起作用。请纠正它。谢谢。 – sree 2015-11-17 13:06:49

这段代码在运行时根据实际创建的对象类型（A或B）调用f（）的正确版本 - 没有“模糊性”。该类型在编译时不能被知道，因为它在运行时被随机选择。

struct A { 
    virtual ~A() {} 
    virtual void f() {} 
}; 

struct B : public A { 
    virtual void f() {} 
}; 


int main() { 
    A * a = 0; 
    if (rand() % 2) { 
     a = new A; 
    } 
    else { 
     a = new B; 
    } 
    a->f(); // calls correct f() 
    delete a; 
}

来源

2010-08-11 09:50:31

您需要在基础和每个派生类中声明一些有用的业务方法。然后你有这样的代码

a->someMethod();

现在的指针可能指向任何派生类的一个实例，所以什么类型指向必须确定的someMethod（）被调用。

来源

2010-08-11 09:52:44 djna

打开这个

void baseclass();

到

virtual void baseclass();

覆盖这在派生类B和C。然后

b *derived1 = new derived1(); 
a *baseptr = derived1; //base pointer pointing to derived class b. 
baseptr->baseclass();

将调用derived1定义，表示运行时多态性。请记住关于如何在Base中使您的析构函数虚拟化。 Some basic reading material for polymorphism

来源

2010-08-11 09:52:57 DumbCoder

运行意味着确切的方法只会在运行时是已知的。考虑这个例子：


class BaseClass 
{ 
public: 
    virtual void method() {...}; 
}; 

class DerivedClassA : public BaseClass 
{ 
    virtual void method() {...}; 
}; 

class DerivedClassB : public BaseClass 
{ 
    virtual void method() {...}; 
}; 

void func(BaseClass* a) 
{ 
    a->method(); 
}

当你实现:: func（）时，你并不知道BaseClass * a所指向的实例类型。它可能是DerivedClassA或DerivedClassB实例等。
您应该认识到，运行时多态性需要语言的特殊支持（也可能是调用“虚拟”函数的一些开销）。在C++中，通过声明基类“virtual”的方法并使用公共继承来“请求”动态多态。

来源

2010-08-11 09:57:05 cybevnm

允许有一个实验

#include <iostream> 
using namespace std; 
class aBaseClass 
{ 

public: 

    void testFunction(){cout<<"hello base";}///Not declared as virtual!!!! 

}; 
class aDerivedClass:public aBaseClass 
{ 
public: 
    void testFunction(){cout<<"hello derived one";} 
}; 

class anotherDerivedClass:public aDerivedClass 
{ 
public: 
    void testFunction(){cout<<"hello derived two";} 

}; 
int main() 
{ 
    aBaseClass *aBaseClassPointer; 
    aBaseClassPointer=new aDerivedClass; 
    aBaseClassPointer->testFunction(); 
}

上面的代码不支持的运行时间的多态性。让我们运行并分析它。输出是

hello base

只要改变行void testFunction(){cout<<"hello base";}到virtual void testFunction(){cout<<"hello base";}在aBaseClass。运行并分析它。我们看到运行时多态性已经实现。适当功能的调用在运行时确定。

在main函数中再次将行aBaseClassPointer=new aDerivedClass更改为aBaseClassPointer=new anotherDerivedClass并查看输出。因此，适当的函数调用是在运行时（程序运行时）确定的。

来源

2013-05-02 14:47:04

运行时多态性究竟意味着什么？

回答

相关问题