一.虚函数使用的注意事项
1.只需要在虚函数的声明处加上 virtual 关键字，函数定义处可以加也可以不加。
2.为了方便，你可以只将基类中的函数声明为虚函数，这样所有子类中具有遮蔽（覆盖）关系的同名函数都将自动成为虚函数。
3. 当在基类中定义了虚函数时，如果派生类没有定义新的函数来遮蔽此函数，那么将使用基类的虚函数。
4.只有子类的虚函数遮蔽基类的虚函数（函数原型相同）才能构成多态（通过基类指针访问子类函数）。例如基类虚函数的原型为virtual void func();，派生类虚函数的原型为virtual void func(int);，那么当基类指针 p 指向派生类对象时，语句p -> func(100);将会出错，而语句p -> func();将调用基类的函数。
5.构造函数不能是虚函数。对于基类的构造函数，它仅仅是在派生类构造函数中被调用，这种机制不同于继承。也就是说，派生类不继承基类的构造函数，将构造函数声明为虚函数没有什么意义。.
6.析构函数可以声明为虚函数，而且有时候必须要声明为虚函数。
二.具体用法
#include <iostream>
using namespace std; //基类Base
class Base{
public:
virtual void func();
virtual void func(int);
};
void Base::func(){
cout<<"void Base::func()"<<endl;
}
void Base::func(int n){
cout<<"void Base::func(int)"<<endl;
} //派生类Derived
class Derived: public Base{
public:
void func();
void func(char *);
};
void Derived::func(){
cout<<"void Derived::func()"<<endl;
}
void Derived::func(char *str){
cout<<"void Derived::func(char *)"<<endl;
} int main(){
Base *p = new Derived();
p -> func(); //输出void Derived::func()
p -> func(); //输出void Base::func(int)
p -> func("http://c.biancheng.net"); //compile error return ;
}
注意：p -> func("http://c.biancheng.net");会出现编译错误，因为子类Derived中的 void func(char *)并未对父类中的virtual void func(int)造成覆盖，两个函数的函数原型不同，所以无法构造多态，自然也不能通过基类的指针来访问子类函数。
三.将基类的析构函数定义成虚函数的必要性
先看下面的例子：
#include <iostream>
using namespace std; //基类
class Base{
public:
Base();
~Base();
protected:
char *str;
};
Base::Base(){
str = new char[];
cout<<"Base constructor"<<endl;
}
Base::~Base(){
delete[] str;
cout<<"Base destructor"<<endl;
} //派生类
class Derived: public Base{
public:
Derived();
~Derived();
private:
char *name;
};
Derived::Derived(){
name = new char[];
cout<<"Derived constructor"<<endl;
}
Derived::~Derived(){
delete[] name;
cout<<"Derived destructor"<<endl;
} int main(){
Base *pb = new Derived();
delete pb; cout<<"-------------------"<<endl; Derived *pd = new Derived();
delete pd; return ;
}
运行结果：
Base constructor
Derived constructor
Base destructor
-------------------
Base constructor
Derived constructor
Derived destructor
Base destructor
在本例中，不调用派生类的析构函数会导致 name 指向的 100 个 char 类型的内存空间得不到释放；除非程序运行结束由操作系统回收，否则就再也没有机会释放这些内存。这是典型的内存泄露。
注意：
delete pb; 不调用子类的析构函数是因为：这里的析构函数是非虚函数，通过指针访问非虚函数时，编译器会根据指针类型来确定要调用的函数；也就是说，指针指向哪个类
就调用哪个类的函数。pb是基类的指针，所以不管它指向的是基类的对象还是子类的对象，始终都是调用基类的析构函数。
delete pd 会同时调用子类和基类的析构函数是因为：pd是子类的指针，编译器会根据它的类型匹配到子类的析构函数，在执行子类的析构函数的过程中，又会调用基类的析构函数
。子类的析构函数始终会调用基类的析构函数，且这个过程是隐式完成的。
更改上面的代码，将基类的析构函数声明为虚函数：
class Base{
public:
Base();
virtual ~Base();
protected:
char *str;
};
将基类的析构函数声明为虚函数后，派生类的析构函数也会自动成为虚函数。这个时候编译器会忽略指针的类型，而根据指针的指向来选择函数；也就是说，指针指向哪个类的对象就调用哪个类的函数。pb、pd 都指向了派生类的对象，所以会调用派生类的析构函数，继而再调用基类的析构函数。如此一来也就解决了内存泄露的问题。
当然了，这里强调的是基类，如果一个类是最终的类，那就没必要再声明为虚函数了。