虚函数的作用主要是实现了多态的机制。简而言之就是用父类型的指针指向其子类的实例，然后通过父类的指针调用实际子类的成员函数。但仅仅可调用父类含有的函数，非父类函数不能调用。
普通虚函数调用
假设我们有下面的类层次：
#include <iostream>
using namespace std;
class A
{
public:
A(){};
~A(){}
virtual void foo()
{
cout << "A::foo() is called" << endl;
}
};
class B :public A
{
public:
B(){}
~B(){}
void foo()
{
cout << "B::foo() is called" << endl;
}
void fun()
{
cout << "B::fun() is called" << endl;
}
virtual void fun1()
{
cout << "B::fun() is called" << endl;
}
};
int main(void)
{
A *a = new B();
a->foo(); // 在这里，a虽然是指向A的指针，但是被调用的函数(foo)却是B的!
// a->fun(); // 这里调用错误，提示：error C2039: “fun”: 不是“A”的成员， e:\debug\base\test\main.cpp(8) : 参见“A”的声明
// a->fun1(); // 这里调用错误，提示：error C2039: “fun1”: 不是“A”的成员， e:\debug\base\test\main.cpp(8) : 参见“A”的声明
return 0;
}
以上例子说明，子类的虚函数替换了父类的同名虚函数（参见【C++学习笔记】虚函数实现多态原理）实现通过父类调用子类函数实现的功能。非父类含有的函数无法调用，可能因为父类中未包含子类中相关函数信息。
构造函数与析构函数调用
假设有如下类层次：
class A
{
public:
A(){ cout << "A::A() is called" << endl; };
~A(){ cout << "A::~A() is called" << endl; }
virtual void foo()
{
cout << "A::foo() is called" << endl;
}
};
class B :public A
{
public:
B(){ cout << "B::B() is called" << endl; }
~B(){ cout << "B::~B() is called" << endl; }
void foo()
{
cout << "B::foo() is called" << endl;
}
};
int main(void)
{
A *a = new B();
a->foo(); // 在这里，a虽然是指向A的指针，但是被调用的函数(foo)却是B的!
delete a;
return 0;
}
程序输出：
A::A() is called
B::B() is called
B::foo() is called
A::~A() is called
由程序输出可以看出，程序先构造父类，再构造子类，析构时未调用子类的析构函数。（这是否可以理解为：父类中未包含子类的信息，所以没有被调用）。若子类的构造函数存在动态内存分配，则会存在内存泄漏的问题。若父类析构函数为虚函数，则程序输出如下：
A::A() is called
B::B() is called
B::foo() is called
B::~B() is called
A::~A() is called
子类的动态内存分配就可以被释放。
虽然调用delete释放父类指针a,但是子类B的析构函数也被调用了。为何父类A析构函数为虚函数，释放父类指针可以调用子类析构函数，父类A析构函数不为虚函数，释放父类指针不调用子类析构函数？父类中也没有包含子类析构函数的信息呀!!!!!!!!!
父子类指针强制转换的安全性
假设有如使用：
class A
{
public:
A(){ cout << "A::A() is called" << endl; };
virtual~A(){ cout << "A::~A() is called" << endl; }
virtual void foo()
{
cout << "A::foo() is called" << endl;
}
};
class B :public A
{
public:
B()
{
cout << "B::B() is called" << endl;
}
virtual~B()
{
cout << "B::~B() is called" << endl;
delete [] pt;
}
void foo()
{
cout << "B::foo() is called" << endl;
}
void fun()
{
cout << "B::fun() is called" << endl;
}
};
int main(void)
{
A *a = new A();
B *b = static_cast<B*>(a); // 需显示强制转换
b->fun();
delete b;
return 0;
}
程序输出：
A::A() is called
B::fun() is called
A::~A() is called
父类指针强制转换为子类指针，并调用了子类函数，释放时释放的是父类A指针，并未释放B指针。父类指针a强制转换过程中并未调用子类B构造函数，释放时也未调用子类B析构函数。原父类动态分配的内存强制转换为子类，向下强制转换为子类存在较大风险，如下所示：
class A
{
public:
A(){ cout << "A::A() is called" << endl; };
virtual~A(){ cout << "A::~A() is called" << endl; }
virtual void foo()
{
cout << "A::foo() is called" << endl;
}
};
class B :public A
{
public:
B()
{
cout << "B::B() is called" << endl;
pt = new int[10];
for (int i = 0; i < 10; i++)
pt[i] = i;
}
virtual~B()
{
cout << "B::~B() is called" << endl;
delete [] pt;
}
void foo()
{
cout << "B::foo() is called" << endl;
}
void fun()
{
cout << "B::fun() is called" << endl;
cout << pt[0] << endl;
}
int *pt;
};
int main(void)
{
A *a = new A();
B *b = static_cast<B*>(a);// 需显示强制转换
b->fun();
delete a;
return 0;
}
程序输出异常，因为子类B调用的函数使用了需要在子类构造函数中动态分配的内存。因为强制转换过程中，未调用子类B的构造函数，pt内存没有进行动态分配。
int main(void)
{
A *a = new B();
B *b = static_cast<B*>(a);
b->fun();
delete a;
return 0;
}
程序输出：
A::A() is called
B::B() is called
B::fun() is called
0
B::~B() is called
A::~A() is called
父类指针强制转换为子类指针，并调用了子类函数(存在使用动态内存分配部分)。此情况说明：父类指针a指向子类指针，再将父类指针转换为子类B使用的安全的。