虚拟函数是实现C中运行时多态的唯一方法吗？

我的一位朋友问我“C中如何实现多态”？我回答“继承”

他说“不,只能使用虚拟功能实现”.

所以我给了他一个如下代码的例子：

#include<iostream>
using namespace std;

class A
{
public:
    int i;
    A(){i=100;}
};

class B : public A
{
public:
    int j;
    B(){i = -1; j = 99;}
};

void func(A& myA)
{
    cout<<myA.i << endl;
}

int main()
{
    B b;
    A* a = new B();
    func(*a);
    func(b);
    delete a;
    return 0;
}

在这里,函数func()引用A,但是我们传递B的对象,我们可以打印公共成员“i”的值.他说这是编译时多态性.

我的问题是：

1)运行时多态是仅实现虚拟函数吗？

2)上面的例子是运行时多态还是编译时？

3)如果我有以下代码：

void func2(A& myA)
{
    cout << myA.i << endl;
    // dynamic/static cast myA to myB
    cout<<myB.j << endl;
}

什么样的多态性呢？还是甚至是多态性？

解决方法

该示例不显示动态多态.被调用的方法在编译时是已知的.关于应该调用哪个方法,没有运行时决定(基于实际的对象类型).不同类型的行为没有不同.

以举例为动态多态性的例子.
您需要在Base类中提供虚拟成员函数,并在派生类中覆盖它.要调用的实际方法由Base类指针指向的对象的实际类型决定.

Online sample：

#include<iostream>
using namespace std;

class A
{
public:
    virtual void doSomething()
    {
        std::cout<<"\nIn A::doSomething()";
    }
};

class B : public A
{
public:
    virtual void doSomething()
    {
        std::cout<<"\nIn B::doSomething()";
    }
};



int main()
{
    B b;
    A obj;
    A* a = &b;
    a->doSomething();

    a = &obj;
    a->doSomething();

    return 0;
}

输出：

In B::doSomething()
In A::doSomething()

Is Runtime polymorphism acheived only with virutal functions?

不,但是虚拟函数是最常用和最正确的方法.
多态可以通过函数指针来实现.考虑以下code example,实际的调用方法根据用户输入在运行时决定.它是一种形式的多态性,不是严格意义上的C意义,它规定了不同类型的不同行为.

#include <iostream>

typedef void (*someFunction)(int,char*);

void FirstsomeFunction(int i,char *c)
{
    std::cout<<"\n In FirstsomeFunction";
}

void SecondsomeFunction(int i,char *c)
{
    std::cout<<"\n In SecondsomeFunction";
}

int main()
{
    someFunction arr[1];
    int x = 0;
    std::cin >> x;

    if(x ==0)
        arr[0] = &FirstsomeFunction;
    else
        arr[0] = &SecondsomeFunction;

    (arr[0])(10,"Hello");

    return 0;
}

Is the example above has runtime polymorphism or compile time?

没有任何种类的多态性.在所有情况下都会使用相同的方法.对于不同的类型没有不同的行为,因此它不被分类为任何种类的多态性.