C++ virtual虚函数

一、定义

简单地说，那些被virtual关键字修饰的成员函数，就是虚函数。虚函数的作用，用专业术语来解释就是实现多态性（Polymorphism），多态性是将接口与实现进行分离；用形象的语言来解释就是实现以共同的方法，但因个体差异，而采用不同的策略。

先看第一段代码

#include <iostream>

using namespace std;

class A
{
    public:
        void print()
        {
            cout<<"This is A"<<endl;
        }
};
 
class B : public A
{
    public:
        void print()
        {
            cout<<"This is B"<<endl;
        }
};

int main()
{
    A a;
    B b;
    a.print();
    b.print();
    return 0;
}

运行结果：

如果改变一下main函数：

int main()
{
    A a;
    B b;
    A *p1 = &a;
    A *p2 = &b;
    p1->print();
    p2->print();
    return 0;
}

运行结果：

虽然p2指向了class B对象，但调用的仍是class A的print。
如果给A的print加上virtual

#include <iostream>

using namespace std;

class A
{
    public:
        virtual void print()
        {
            cout<<"This is A"<<endl;
        }
};
 
class B : public A
{
    public:
        void print()
        {
            cout<<"This is B"<<endl;
        }
};

int main()
{
    A a;
    B b;
    A *p1 = &a;
    A *p2 = &b;
    p1->print();
    p2->print();
    return 0;
}

运行结果：

这时候，不仅class A成为了虚函数，其派生类class B也已经成为虚函数，只是代码里可写可不写，如果没写，编译器会自动加上。

二、原理

虚函数是如何做到因对象的不同而调用其相应的函数的：

class A{//虚函数示例代码
    public:
        virtual void fun(){cout<<1<<endl;}
        virtual void fun2(){cout<<2<<endl;}
};
class B : public A{
    public:
        void fun(){cout<<3<<endl;}
        void fun2(){cout<<4<<endl;}
};

由于这两个类中有虚函数存在，所以编译器就会为他们两个分别插入一段你不知道的数据，并为他们分别创建一个表。那段数据叫做vptr指针，指向那个表。那个表叫做vtbl，每个类都有自己的vtbl，vtbl的作用就是保存自己类中虚函数的地址，我们可以把vtbl形象地看成一个数组，这个数组的每个元素存放的就是虚函数的地址。

A *p = new B;
p -> fun();

上面的代码毫无疑问调用了B::fun。

#include<iostream>
using namespace std;
//将上面“虚函数示例代码”添加在这里
void CallVirtualFun(void*pThis,intindex=0)
{
    void(*funptr)(void*);
    long lVptrAddr;
    memcpy(&lVptrAddr,pThis,4);
    memcpy(&funptr,reinterpret_cast<long*>(lVptrAddr)+index,4);
    funptr(pThis);//调用
}
int main()
{
    A *p = new B;
    CallVirtualFun(p);//调用虚函数p->fun()
    CallVirtualFun(p,1);//调用虚函数p->fun2()
    system("pause");
    return 0;
}

编译器在编译时，会进行类似于上面的代码的过程:
首先new B是向内存（内存分5个区：全局名字空间，自由存储区，寄存器，代码空间，栈）自由存储区申请一个内存单元的地址然后隐式地保存在一个指针中.然后把这个地址赋值给A类型的指针P，指针P后面用来存储从vtbl中取出的地址。
memcpy(&lVptrAddr,pThis,4)是将vtbl的地址（即fun的地址）保存在lVptrAddr里面；
而memcpy(&funptr,reinterpret_cast<long*>(lVptrAddr)+index,4)则是将fun2的地址（fun2的vtbl）保存到lVptrAddr的后面（类似数组）。
这样，我们在调用虚函数的时候，实际上还调用了获取虚函数地址的代码，所以虚函数的效率较低。

三、用法

转自该地址
1.多态
就像前面说的，以共同的方法，但因个体差异，而采用不同的策略。

#include<iostream> 
using namespace std;
class A
{
public:
    virtual void display(){ cout<<"A"<<endl; }
};
class B : public A
{
public:
    void display(){ cout<<"B"<<endl; }
};
void doDisplay(A *p)
{
    p->display();
    delete p;
} 
int main(int argc,char* argv[])
{     
    doDisplay(new B());
    return 0;
}

这段代码打印出的结果为B，但是当把A类中的virtual去掉之后打印出的就为A。当基类中没有virtual的时候，编译器在编译的时候把p看做A类的对象，调用的自然就是A类的方法。但是加上virtual之后，将dispaly方法变成了虚方法，这样调用的时候编译器会看调用的究竟是谁的实例化对象，这样就实现了多态的效果。也就是说，当基类的派生类中有重写过基类的虚方法的时候，使用基类的指针指向派生类的对象，调用这个方法实际上调用的会是派生类最后实现的方法。
2.虚继承：解决数据冗余

#include<iostream>
using namespace std;
class Person
{
public: 
	Person(){ cout<<"Person构造"<<endl; }
	~Person(){ cout<<"Person析构"<<endl; }
};
class Teacher : virtual public Person
{
public: 
	Teacher(){ cout<<"Teacher构造"<<endl; }
	~Teacher(){ cout<<"Teacher析构"<<endl; }
};
class Student : virtual public Person
{
public: 
	Student(){ cout<<"Student构造"<<endl; }
	~Student(){ cout<<"Student析构"<<endl; }
};
class TS : public Teacher, public Student
{
	public: TS(){ cout<<"TS构造"<<endl; }
	~TS(){ cout<<"TS析构"<<endl; }
};
int main(int argc,char* argv[])
{
    TS ts;
    return 0;
}

运行结果：

如果把Person类的virtual去掉：

大家可以很清楚的看到这个结果明显不是我们所期望的。我们在构造TS的时候需要先构造他的基类，也就是Teacher类和Student类。而Teacher类和Student类由都继承于Person类。这样就导致了构造TS的时候实例化了两个Person类。同样的道理，析构的时候也是析构了两次Person类，这是非常危险的，也就引发出了virtual的第三种用法，虚析构。
3.虚析构

#include<iostream>
using namespace std;
class Person
{
public:
	Person() {name = new char[16];cout<<"Person构造"<<endl;}
	virtual ~Person() {delete []name;cout<<"Person析构"<<endl;}
private:
	char *name;
};
class Teacher :virtual public Person
{
public: 
	Teacher(){ cout<<"Teacher构造"<<endl; }
	~Teacher(){ cout<<"Teacher析构"<<endl; }
};
class Student :virtual public Person
{
public: 
	Student(){ cout<<"Student构造"<<endl; }
	~Student(){ cout<<"Student析构"<<endl; }
};
class TS : public Teacher,public Student
{
public: 
	TS(){ cout<<"TS构造"<<endl; }
	~TS(){ cout<<"TS析构"<<ENDL; }
};
int main(int argc,char* argv[])
{
	Person *p = new TS();
	delete p;
	return 0;
}

运行结果：

Person构造
Teacher构造
Student构造
TS构造
TS析构
Student析构
Teacher析构
Person析构

但是当我们把Person类中析构前面的virtual去掉之后的运行结果为：

Person构造
Teacher构造
Student构造
TS构造
Person析构
程序崩溃

很明显这个结果不是我们想要的程序，崩溃造成的后果是不可预计的，所以我们一定要注意在基类的析构函数前面加上virtual，使其变成虚析构在C++程序中使用虚函数，虚继承和虚析构是很好的习惯 可以避免许多的问题。