简介
本章节会介绍在C++中虚函数及纯虚函数的主要作用，C++也是通过虚函数实现动态绑定，本小节不会去讲述动态绑定内部实现原理，具体可以参考[C++动态绑定原理].
结构图
-
虚函数
- 成员函数(member function)为虚函数(virtual function)
- 析构函数为虚函数
-
纯虚函数
- 成员函数为纯虚函数(pure virtual function)
- 析构函数为纯虚函数
虚函数
-
成员函数为虚函数
在开始虚函数之前，先看一段代码分析其中的问题。
#include <iostream>
class Animal {
public:
Animal() {}
~Animal(){}
void run(void) {
std::cout << "Animal run..." << std::endl;
}
};
class Cat : public Animal{
public:
Cat() : Animal(){}
void run(void) {
std::cout << "Cat run..." << std::endl;
}
};
int main(int argc,char** argv)
{
Animal *animal = new Cat; //创建Cat对象，然后执行向上类型转换
animal->run();
return 0;
}
/*输出结果*/
//Animal run...
在以上代码中，animal所指向的为Cat对象，但是当调 用run函数的时候，打印的值是"Animal run...",并不是"Cat run...",这是因为当编译器看到"animal"的指针类型是"Animal"时，自然而然的就会调用Animal::run(),在编译时期，就已经确定所要调用的具体函数，这也就是所说的静态绑定。
在开始后面讲解之前，需要先记住两点知识：
1. 声明一个虚函数需要使用关键字:virtual
2. 当基类(或称为父类)中的某函数A()被声明为虚函数之后，在继生类(或称为子类)中重载的A(),即不使用virtual修饰，也是虚函数
现在对上面的代码进行修改，将void Animal::run()修改为虚函数，即改为virtual void Animal::run(),观察修改后的运行情况。
#include <iostream>
class Animal {
public:
Animal() {}
~Animal() {}
virtual void run(void) { //!!!!!!!!!!注意此处的修改
std::cout << "Animal run..." << std::endl;
}
};
class Cat : public Animal {
public:
Cat() : Animal() {}
void run(void) {
std::cout << "Cat run..." << std::endl;
}
};
int main(int argc, char** argv)
{
Animal *animal = new Cat; //创建Cat对象，然后执行向上类型转换
animal->run();
return 0;
}
//输出结果：
//Cat run...
当Animal::run()为虚函数时，输出结果为Cat run...,这也就是虚函数的作用，此时在程序运行时去决定调用哪一个run()函数，这也就是动态绑定。在这里animal实际上指向的是Cat对象，所以调用的是Cat::run()。
-
析构函数为虚函数
当基类中包含虚成员函数的时候，一般会把析构函数
也定义为虚析构函数虚析构函数和虚成员函数在函数定义上是一样的，只需要添加
virtual关键字就可以了，这里主要介绍定义虚析构函数的原因：- 为了通过基类指针正确释放该指针所指向的对象(该指针可能指向一个子类)
通过实例了解一下：
#include <iostream>
class Base1 {
public:
virtual void print(void) {
std::cout << "Base1 print" << std::endl;
}
~Base1(){
std::cout << "Base1's destructor" << std::endl;
}
};
class Derived1 : public Base1
{
public:
Derived1(int n) {
p = new char[n];
}
void print(void) {
std::cout << "Derived1 print" << std::endl;
}
~Derived1() {
delete[]p;
std::cout << "Derived1's destructor" << std::endl;
}
private:
char *p;
};
class Base2 {
public:
virtual void print(void) {
std::cout << "Base2 print" << std::endl;
}
virtual ~Base2() {
std::cout << "Base2's destructor" << std::endl;
}
};
class Derived2 : public Base2
{
public:
Derived2(int n) {
p = new char[n];
}
void print(void) {
std::cout << "Derived2 print" << std::endl;
}
~Derived2() {
delete[]p;
std::cout << "Derived2's destructor" << std::endl;
}
private:
char *p;
};
int main(int argc, char** argv)
{
std::cout << "Base1 test: \n";
Base1 *base1 = new Derived1(5);
base1->print();
delete base1;
std::cout << "\n\nBase2 test: \n";
Base2 *base2 = new Derived2(5);
base2->print();
delete base2;
return 0;
}
//输出结果：
Base1 test:
Derived1 print
Base1's destructor
Base2 test:
Derived2 print
Derived2's destructor
Base2's destructor
base1实际指向Derived1对象，在Derived中通过new在堆上创建了5个char,但是当执行delete base1;的时候，只调用了Base1::~Base1()，但却没有调用Derived1::~Derived1(),最终导致这5个char无法释放，而导致内存泄漏。
当把Base2的析构函数声明为虚函数的时候，调用delete base2,会先调用Derived2::~Derived2(),然后再调用Base2::~Base2(),所有内存成功释放。
纯虚函数
TODO
