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;
}

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

#包括
使用名称空间std；
甲级
{
公众：
int i；
A（）{i=100；}
};
B类：公共A
{
公众：
int j；
B（）{i=-1；j=99；}
};
无效函数（A&myA）
{
cout该示例没有显示动态多态性。要调用的方法在编译时是已知的。对于应该调用哪个方法，没有运行时决策（基于实际对象类型）。对于不同的类型，没有不同的行为

例如，该示例是动态多态性的示例。

您需要在基类中提供一个
virtual
成员函数，并在派生类中覆盖它。要调用的实际方法由基类指针指向的对象的实际类型决定

：

#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()

不需要，但虚拟功能是最常见和正确的方法。

多态性可以通过函数指针来实现。考虑下面的<强> <强>，实际调用的方法是根据用户输入在运行时决定的，它是一种多态性形式，它不是严格意义上的C++，它对不同类型的任务有不同的行为。
#包括
typedef void（*someFunction）（int，char*）；
void FirstsomeFunction（int i，char*c）
{
多态性是通过虚拟函数实现的。但要产生任何效果，即根据类型不同的行为，您也需要继承

struct A {
    virtual void f() = 0;
};

struct B : public A {
    void f() {
        // do B things
        std::cout << "B::f() called\n";
    }
};

struct C : public A {
    void f() {
        // do C things
        std::cout << "C::f() called\n";
    }
};

结构A{
虚空f（）=0；
};
结构B：公共A{
void f（）{
//做事
你写的不是多态性

<>这是C++中多态性的一个例子：

#include<iostream>
using namespace std;

class A
{
public:
    virtual void func(){
        cout << "printing A" << endl;
    }

    virtual ~A(){}
};

class B : public A
{
public:
    void func(){
        cout << "printing B" << endl;
    }
};

int main()
{
    A* a = new A();
    A* b = new B();

    a->func(); // "printing A"
    b->func(); // "printing B"

    delete a;
    delete b;

    return 0;
}

#包括
使用名称空间std；
甲级
{
公众：
虚空函数（）{
coutC
语言是一个多态函数

您可以将各种句柄传递给它，它可以打印到文件、标准输出、打印机，以及系统可以表示为流的任何内容

FILE* file = fopen("output.txt", "w");                    // a file
FILE* file = stdout;                                      // standard output
FILE* file = fopen("/dev/usb/lp0", "w");                  // a usb printer
FILE* file = popen("/usr/bin/lpr -P PDF", "w");           // a PDF file
FILE* file = fdopen(socket(AF_INET,SOCK_STREAM,0), "r+"); // network socket

fprintf(file, "Hello World.\n");

[C++]

多态性定义为一个接口，用于控制对一般操作类的访问。有两种类型的多态性，一种是编译时多态性，另一种是运行时多态性。编译时多态性是函数和运算符重载。运行时多态性使用继承和虚拟函数完成

多态性意味着函数在不同的时间采用不同的形式。在编译时，它被称为函数重载。例如，一个程序可以由两个函数组成，其中一个可以执行整数加法，另一个可以执行浮点数加法，但函数的名称可以相同，例如add添加（）被称为重载。两个或多个函数可以具有相同的名称，但它们的参数列表在参数或数据类型方面应该不同。只能在返回类型上不同的函数不能重载。编译器将根据传递的参数类型选择正确的函数。对于类constructor可能会被重载，因为可以同时存在已初始化和未初始化的对象

<我的一个朋友问我“C++中的运行时多态性是如何实现的？”我回答“继承”。
他说：“不，只有使用虚拟功能才能实现。”

第一，多态性是一个模糊的概念：在一般的计算科学中，它指的是隐式调用特定类型的代码的能力，无论是在编译时还是运行时。在C++标准中，定义为虚拟调度（这是标准的永久性）非常狭隘。很显然，对于你朋友的问题，他在C++中如何实现它的观点必须是从C++的外部——在计算科学术语的更大的上下文中。
当然，虚拟功能/调度是一个答案，但它们是唯一的答案吗
为了尝试回答这个问题，有助于对什么行为符合运行时多态性的定义有一个清晰的概念。请考虑：

void f(X& x)
{
    // the only situation where C++ doesn't know the run-time type of a variable is
    // where it's an instance of a class/struct accepted by reference or pointer

    ...some operation involving "x"...
}

任何可能导致所调用操作的不同机器代码涉及“x”的机制，其中原因与“x”的运行时类型有关，非常接近于运行时多态，但还有最后一个问题：分支是由语言隐式决定的，还是由程序员显式安排的

在虚拟分派的情况下，编译器隐式地知道如何创建虚拟分派表和查找分支到适当类型的代码

但是，假设我们有一个函数指针，它以前被设置为地址类型适当的代码，或者一个类型特定的数字或枚举，用于控制一个
开关
到一个类型特定的
案例
。这些函数在功能上实现了与运行时虚拟调度相同的行为，但是设置必须由开发人员显式完成因为没有编译器的强制执行，以确保确定是纯运行时类型的。它们是否符合标准是可争论的。因为C++在虚拟调度中有一个完全隐式的机制，并且因为C++中的多态性有一个与虚拟调度相关的狭义定义，所以我猜想大多数C++。+程序员会说“不”

但在C世界中，将say
qsort
或
bsearch
（两个通过函数指针参数使用运行时分派处理任意类型的标准libC函数）描述为运行时多态性可能有助于快速理解……但更正常的说法是，它们是通用实现

不过，还是有疑问的
void f(X& x)
{
    // the only situation where C++ doesn't know the run-time type of a variable is
    // where it's an instance of a class/struct accepted by reference or pointer

    ...some operation involving "x"...
}

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