C++ 虚函数virtual的引入和应用

        来回顾一下使用引用或指针调用方法的过程。请看下面的代码:
BrassPlus ophelia;        // 子类对象
Brass * bp;                // 基类指针
bp = &ophelia;            // 让基类指针指向子类对象
bp->ViewAcct();            // ViewAcct() 如果基类和子类都有这个函数，那么这里应该调用哪一个呢？

        如果在基类中没有将 ViewAcct()声明为虚的，则 bp-ViewAcct()将根据指针类型(Brass*)调用 Brass::ViewAcct()。指针类型在编译时已知，因此编译器在编译时，可以将 ViewAcct()关联到Brass::ViewAcct()。总之，编译器对非虚方法使用静态联编。

        然而，如果在基类中将 ViewAcct()声明为虚的，则 bp->ViewAcct()根据对象类型(BrassPlus)调用BrassPlus::ViewAcct()。在这个例子中对象类型为 BrassPlus，但通常只有在运行程序时才能确定对象的类型。所以编译器生成的代码将在程序执行时，根据对象类型将 ViewAcct()关联到 Brass::ViewAcct()或 BrassPlus::ViewAcct()。总之，编译器对虚方法使用动态联编。

        在大多数情况下，动态联编很好，因为它让程序能够选择为特定类型设计的方法。因此，您可能会问:
1. 为什么有两种类型的联编? 
2. 既然动态联编如此之好，为什么不将它设置成默认的?
3. 动态联编是如何工作的?

        下面来看看这些问题的答案。

        如果动态联编让您能够重新定义类方法，而静态联编在这方面很差，为何不摒弃静态联编呢?原因有两个-效率和概念模型。

        首先来看效率。为使程序能够在运行阶段进行决策，必须采取一些方法来跟踪基类指针或引用指向的对象类型，这增加了额外的处理开销。例如，如果类不会用作基类，则不需要动态联编。同样，如果派生类不重新定义基类的任何方法，也不需要使用动态联编。在这些情况下，使用静态联编更合理，效率也更高。由于静态联编的效率更高，因此被设置为 C++的默认选择。Strousstrup说，C++的指导原则之一是，不要为不使用的特性付出代价(内存或者处理时间)。仅当程序设计确实需要虚函数时，才使用它们。

                接下来看概念模型。在设计类时可能包含一些不在派生类重新定义的成员函数。不将该类函数设置为虚函数，有两方面的好处:首先效率更高;其次，指出不要重新定义该函数。这表明，仅将那些预期将被重新定义的方法声明为虚的。

提示:如果要在派生类中重新定义基类的方法，则将它设置为虚方法:否则，设置为非虚方法。

        当然，设计类时，方法属于哪种情况有时并不那么明显。与现实世界中的很多方面一样，类设计并不是一个线性过程。

        虚函数的工作原理？

        通常，编译器处理虚函数的方法是:给每个对象添加一个隐藏成员。隐藏成员中保存了一个指向函数地址数组的指针。这种数组称为虚函数表 (virtual function tablevbl)。

        虚函数表中存储了为类对象进行声明的虚函数的地址。例如，基类对象包含一个指针，该指针指向基类中所有虚函数的地址表。派生类对象将包含一个指向独立地址表的指针。如果派生类提供了虚函数的新定义，该虚函数表将保存新函数的地址:如果派生类没有重新定义虚函数，该 vtbl将保存函数原始版本的地址。如果派生类定义了新的虚函数，则该函数的地址也将被添加到 vtbl中。 注意无论类中包含的函数是1个还是10个，都只需要在对象中添加1地址成员，只是表的大小不同而已。

        调用虚函数时，程序将查看存储在对象中的 vtbl地址，然后转向相应的函数地址表。如果使用类声明中定义的第一个虚函数，则程序将使用数组中的第一个函数地址，并执行具有该地址的函数。如果使用类声明中的第三个虚函数，程序将使用地址为数组中第三个元素的函数。

        总之，使用虚函数时，在内存和执行速度方面有一定的成本，包括:
1. 每个对象都将增大，增大量为存储地址的空间;
2. 对于每个类，编译器都创建--个虚函数地址表(数组);
3. 对于每个函数调用，都需要执行一项额外的操作，即到表中查找地址。
虽然非虚函数的效率比虚函数稍高，但不具备动态联编功能。

        有关虚函数注意事项
        我们已经讨论了虚函数的一些要点。
1. 在基类方法的声明中使用关键字 virtal可该方法在基类以及所有的派生类(包括从派生类派生出来的类)中是虚的。
2. 如果使用指向对象的引用或指针来调用虚方法，程序将使用为对象类型定义的方法，而不使用为引用或指针类型定义的方法。这称为动态联编或晚期联编。这种行为非常重要，因为这样基类指针或引用可以指向派生类对象。
3. 如果定义的类将被用作基类，则应将那些要在派生类中重新定义的类方法声明为虚的。

        对于虚方法，还需要了解其他一些知识，其中有的已经介绍过。下面来看看这些内容。

1. 构造函数
        构造函数不能是虚函数。创建派生类对象时，将调用派生类的构造函数，而不是基类的构造函数，然后，派生类的构造函数将使用基类的一个构造函数，这种顺序不同于继承机制。因此，派生类不继承基类的构造函数，所以将类构造函数声明为虚的没什么意义。

2. 析构函数
        析构函数应当是虚函数，除非类不用做基类。例如，假设 Employee 是基类, Singer 是派生类，并添加一个char*成员，该成员指向由new分配的内存。当Singer 对象过期时，必须调用~Singer()析构函数来释放内存。

        如果使用默认的静态联编，delete语句将调用~Employee()析构函数。这将释放由_Singer 对象中的Employee 部分指向的内存，但不会释放新的类成员指向的内存。但如果析构函数是虚的，则上述代码将先调用~Singer 析构函数释放Singer 组件指向的内存然后，用~Employee()构函数来释放由Employec组件指向的内存。
这意味着，即使基类不需要显式析构函数提供服务，也不应依赖于默认构造函数，而应提供虚析构函数，即使它不执行任何操作:
        virtual -BaseClass()

顺便说一句，给类定义一个虚析构函数并非错误，即使这个类不用做基类;这只是一个效率方面的问题。
提示:通常应给基类提供一个虚析构函数，即使它并不需要析构函数。

3. 友元
        友元不能是虚函数，因为友元不是类成员，而只有成员才能是虚函数。如果由于这个原因引起了设计问题，可以通过让友元函数使用虚成员函数来解决。

4. 没有重新定义

        如果派生类没有重新定义函数，将使用该函数的基类版本。如果派生类位于派生链中，则将使用最新的虚函数版本，例外的情况是基类版本是隐藏的。

5. 重新定义将隐藏方法
class Dwelling
{
    public:
        virtual void showperks(int a) const;
};

class Hovel : public Dwelling
{
    public:
        virtual void showperks() const;
        ...
};

这将导致问题，如：
    Hovel trump;
    trump.showperks();        // 是有效的
    trump.showperks(5);        // 是无效的

        新定义将showperks()定义为一个不接受任何参数的函数。重新定义不会生成函数的两个成灾版本，而是隐藏了接受一个int参数的基类版本。总之，重新定义继承的方法并不是重载。如果在派生类中重新定义函数，将不是使用相同的函数特征标覆盖基类声明，而是隐藏同名的基类方法，不管参数特征标如何。

        这引出了两条经验规则，第一，如果重新定义继承类方法，应确保与原来的原型完全相同，但如哦返回类型是基类引用或指针，则可以修改为指向派生类的引用或指针（这种例外是新出现的）。这种特性被称为返回类型协变。因为允许返回类型随类类型的变化而变化。

示例源码：

// Len2024_0106_01.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//

#include 
using namespace std;

class Base
{
private:
	int m_nNum1;
	int m_nNum2;

public:
	Base(int num1, int num2)
	{
		m_nNum1 = num1;
		m_nNum2 = num2;
	}
	virtual void Show()
	{
		int data = m_nNum1 + m_nNum2;
		cout << m_nNum1 << "+" << m_nNum2 << "=" << data << endl;
	}
};

class Child : public Base
{
private:
	int m_nNum3;
	int m_nNum4;

public:
	Child(int num1, int num2, int num3, int num4) :Base(num1, num2) 
	{
		m_nNum3 = num3;
		m_nNum4 = num4;
	}

	virtual void Show()
	{
		int data = m_nNum3 + m_nNum4;
		cout << m_nNum3 << "+" << m_nNum4 << "=" << data << endl;
	}
};

class Grandson :public Child
{
private:
	int m_nNum5;
	int m_nNum6;
public:
	Grandson(int num1, int num2, int num3, int num4, int num5, int num6) :Child(num1, num2, num3, num4)
	{
		m_nNum5 = num5;
		m_nNum6 = num6;
	}

	virtual void Show()
	{
		int data = m_nNum5+ m_nNum6;
		cout << m_nNum5 << "+" << m_nNum6 <<"="<< data<< endl;
	}
};

int main()
{
	Base* base1 = new Base(11, 21);
	base1->Show();  // 调用基类的show

	cout << endl;
	Base* base2 = new Child(101, 201, 301, 401);
	base2->Show(); // 调用Child类的show

	cout << endl;
	Base* base3 = new Grandson(1001, 2001, 3001, 4001, 5001, 6001);
	base3->Show();  调用Grandson类的show
}

执行结果：