一、定义
简单地说,那些被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++程序中使用虚函数,虚继承和虚析构是很好的习惯 可以避免许多的问题。