我正在学习C++，我刚刚开始学习虚拟函数。
从我（在书中和网上）读到的内容来看，虚拟函数是基类中的函数，可以在派生类中重写。
但在本书的早些时候，当我学习基本继承时，我能够在派生类中重写基函数，而不使用虚函数。
那么我在这里错过了什么？我知道虚拟函数还有很多，它似乎很重要，所以我想清楚它到底是什么。我只是在网上找不到一个直截了当的答案。
当前回答
如果基类是base，派生类是Der，则可以有一个base*p指针，它实际上指向Der的实例。当您调用p->foo（）；时；，如果foo不是虚拟的，则执行Base版本的foo，忽略p实际上指向Der的事实。如果foo是虚拟的，则p->foo（）执行foo的“最叶”覆盖，充分考虑指向项的实际类。因此，虚拟和非虚拟之间的区别实际上非常关键：前者允许运行时多态性，这是OO编程的核心概念，而后者则不允许。
其他回答
OOP答案：亚型多态性
在C++中，需要虚拟方法来实现多态性，如果应用维基百科中的定义，则更准确地说是子类型或子类型多态性。
维基百科，分类，2019-01-09：在编程语言理论中，子类型化（也称为子类型多态性或包含多态性）是类型多态性的一种形式，其中子类型是通过某种可替代性概念与另一个数据类型（父类型）相关的数据类型，这意味着程序元素（通常是子例程或函数），编写为对父类型的元素进行操作也可以对子类型的元素执行操作。
注意：子类型表示基类，子类型表示继承类。
关于亚型多态性的进一步阅读
https://en.wikipedia.org/wiki/Subtypinghttps://en.wikipedia.org/wiki/Polymorphism_（computer_science）#子类型
技术答案：动态调度
如果您有一个指向基类的指针，那么方法的调用（声明为虚拟）将被分派到所创建对象的实际类的方法。这就是亚型多态性是如何在C++中实现的。
进一步阅读C++中的多态性与动态调度
http://www.cplusplus.com/doc/tutorial/polymorphism/https://en.cppreference.com/w/cpp/language/virtual
实现答案：创建vtable条目
对于方法上的每个修饰符“virtual”，C++编译器通常会在声明方法的类的vtable中创建一个条目。这就是常见的C++编译器实现动态调度的方式。
进一步阅读vtables
https://en.wikipedia.org/wiki/Virtual_method_table
示例代码
#include <iostream>
using namespace std;
class Animal {
public:
virtual void MakeTypicalNoise() = 0; // no implementation needed, for abstract classes
virtual ~Animal(){};
};
class Cat : public Animal {
public:
virtual void MakeTypicalNoise()
{
cout << "Meow!" << endl;
}
};
class Dog : public Animal {
public:
virtual void MakeTypicalNoise() { // needs to be virtual, if subtype polymorphism is also needed for Dogs
cout << "Woof!" << endl;
}
};
class Doberman : public Dog {
public:
virtual void MakeTypicalNoise() {
cout << "Woo, woo, woow!";
cout << " ... ";
Dog::MakeTypicalNoise();
}
};
int main() {
Animal* apObject[] = { new Cat(), new Dog(), new Doberman() };
const int cnAnimals = sizeof(apObject)/sizeof(Animal*);
for ( int i = 0; i < cnAnimals; i++ ) {
apObject[i]->MakeTypicalNoise();
}
for ( int i = 0; i < cnAnimals; i++ ) {
delete apObject[i];
}
return 0;
}
示例代码输出
Meow!
Woof!
Woo, woo, woow! ... Woof!
代码示例的UML类图
您需要至少1个级别的继承和一个升级来演示它。下面是一个非常简单的示例：
class Animal
{
public:
// turn the following virtual modifier on/off to see what happens
//virtual
std::string Says() { return "?"; }
};
class Dog: public Animal
{
public: std::string Says() { return "Woof"; }
};
void test()
{
Dog* d = new Dog();
Animal* a = d; // refer to Dog instance with Animal pointer
std::cout << d->Says(); // always Woof
std::cout << a->Says(); // Woof or ?, depends on virtual
}
您需要虚拟方法来实现安全的下变频、简单和简洁。
这就是虚拟方法所做的：它们安全地向下转换，使用明显简单而简洁的代码，避免了在更复杂和冗长的代码中进行不安全的手动转换。
Non-virtual method ⇒ static binding ========================================
以下代码故意“不正确”。它没有将value方法声明为virtual，因此会产生意外的“错误”结果，即0:
#include <iostream>
using namespace std;
class Expression
{
public:
auto value() const
-> double
{ return 0.0; } // This should never be invoked, really.
};
class Number
: public Expression
{
private:
double number_;
public:
auto value() const
-> double
{ return number_; } // This is OK.
Number( double const number )
: Expression()
, number_( number )
{}
};
class Sum
: public Expression
{
private:
Expression const* a_;
Expression const* b_;
public:
auto value() const
-> double
{ return a_->value() + b_->value(); } // Uhm, bad! Very bad!
Sum( Expression const* const a, Expression const* const b )
: Expression()
, a_( a )
, b_( b )
{}
};
auto main() -> int
{
Number const a( 3.14 );
Number const b( 2.72 );
Number const c( 1.0 );
Sum const sum_ab( &a, &b );
Sum const sum( &sum_ab, &c );
cout << sum.value() << endl;
}
在注释为“坏”的行中，调用了Expression:：value方法，因为静态已知类型（编译时已知的类型）是Expression，而value方法不是虚拟的。
Virtual method ⇒ dynamic binding. ======================================
在静态已知类型表达式中将值声明为virtual可确保每次调用都会检查这是什么实际类型的对象，并调用该动态类型的值的相关实现：
#include <iostream>
using namespace std;
class Expression
{
public:
virtual
auto value() const -> double
= 0;
};
class Number
: public Expression
{
private:
double number_;
public:
auto value() const -> double
override
{ return number_; }
Number( double const number )
: Expression()
, number_( number )
{}
};
class Sum
: public Expression
{
private:
Expression const* a_;
Expression const* b_;
public:
auto value() const -> double
override
{ return a_->value() + b_->value(); } // Dynamic binding, OK!
Sum( Expression const* const a, Expression const* const b )
: Expression()
, a_( a )
, b_( b )
{}
};
auto main() -> int
{
Number const a( 3.14 );
Number const b( 2.72 );
Number const c( 1.0 );
Sum const sum_ab( &a, &b );
Sum const sum( &sum_ab, &c );
cout << sum.value() << endl;
}
这里的输出应该是6.86，因为虚拟方法是虚拟调用的。这也称为调用的动态绑定。执行一点检查，找到对象的实际动态类型，并调用该动态类型的相关方法实现。
相关的实现是最特定（最派生）类中的实现。
注意，这里的派生类中的方法实现没有标记为virtual，而是标记为override。它们可以被标记为虚拟，但它们是自动虚拟的。override关键字确保如果某个基类中没有这样的虚拟方法，那么您将得到一个错误（这是可取的）。
The ugliness of doing this without virtual methods ==================================================
如果没有虚拟绑定，则必须实现一些自己动手版本的动态绑定。这通常涉及不安全的手动降级、复杂性和冗长。
对于单个函数的情况，如这里所示，将函数指针存储在对象中并通过该函数指针进行调用就足够了，但即使如此，它也会涉及一些不安全的下变频、复杂性和冗长性，即：
#include <iostream>
using namespace std;
class Expression
{
protected:
typedef auto Value_func( Expression const* ) -> double;
Value_func* value_func_;
public:
auto value() const
-> double
{ return value_func_( this ); }
Expression(): value_func_( nullptr ) {} // Like a pure virtual.
};
class Number
: public Expression
{
private:
double number_;
static
auto specific_value_func( Expression const* expr )
-> double
{ return static_cast<Number const*>( expr )->number_; }
public:
Number( double const number )
: Expression()
, number_( number )
{ value_func_ = &Number::specific_value_func; }
};
class Sum
: public Expression
{
private:
Expression const* a_;
Expression const* b_;
static
auto specific_value_func( Expression const* expr )
-> double
{
auto const p_self = static_cast<Sum const*>( expr );
return p_self->a_->value() + p_self->b_->value();
}
public:
Sum( Expression const* const a, Expression const* const b )
: Expression()
, a_( a )
, b_( b )
{ value_func_ = &Sum::specific_value_func; }
};
auto main() -> int
{
Number const a( 3.14 );
Number const b( 2.72 );
Number const c( 1.0 );
Sum const sum_ab( &a, &b );
Sum const sum( &sum_ab, &c );
cout << sum.value() << endl;
}
看待这一点的一种积极方式是，如果您遇到了如上所述的不安全的下变频、复杂性和冗长，那么通常一个或多个虚拟方法确实会有帮助。
虚拟函数用于支持运行时多态性。
也就是说，virtual关键字告诉编译器不要在编译时做出（函数绑定的）决定，而是推迟到运行时”。
您可以通过在函数的基类声明中的关键字virtual之前使其成为虚拟函数。例如类基础{虚虚函数（）；}当基类具有虚拟成员函数时，从基类继承的任何类都可以使用完全相同的原型重新定义该函数，即只能重新定义功能，而不能重新定义函数的接口。类派生：公共基{void函数（）；}基类指针可用于指向基类对象和派生类对象。当使用基类指针调用虚拟函数时，编译器在运行时决定要调用函数的哪个版本（即基类版本或重写的派生类版本）。这被称为运行时多态性。
为什么我们需要C++中的虚拟方法？
快速回答：
它为我们提供了面向对象编程所需的“要素”之一。
在Bjarne Stroustrup C++编程：原理与实践中，（14.3）：
虚拟函数提供了在基类中定义函数的能力，并在用户调用基类函数时在派生类中具有相同名称和类型的函数。这通常称为运行时多态性、动态调度或运行时调度，因为调用的函数是在运行时根据所使用的对象类型确定的。
如果您需要虚拟函数调用2，这是最快、更有效的实现。
为了处理虚拟调用，需要一条或多条与派生对象3相关的数据。通常的做法是添加函数表的地址。该表通常称为虚拟表或虚拟函数表，其地址通常称为虚指针。每个虚拟函数在虚拟表中都有一个槽。根据调用者的对象（派生）类型，虚拟函数依次调用相应的重写。
1.使用继承、运行时多态性和封装是面向对象编程的最常见定义。
2.您不能在运行时使用其他语言功能在备选方案中进行选择，从而使功能更快或使用更少的内存。Bjarne Stroustrup C++编程：原理与实践。(14.3.1).
3.当我们调用包含虚拟函数的基类时，可以判断哪个函数真正被调用。
