前言…
说来许久没更新博客，但小张并没有荒废，意志也没有消退。
此刻正被老板派到河北某村儿出差，手里还没有心仪的offer，实惨。

言归正传，直接给出用于测试cpp虚函数的纯虚函数，虚函数，动态多态，构造函数与析构函数的代码，各位看官应该一看便知其中的奥妙：

show you my code

// 虚函数动态多态
// Created by wbzhang on 2020/9/19.
//

#include <iostream>
#include <string>
using namespace std;

struct Point2i
{
	int x,y;
};

// 基类 Shape
class Shape
{
protected:
	int width;
	int height;
public:
	static string ShapeName; // 静态成员

	static void shapePrint()
	{
		std::printf("ShapeName is %s in stacic.","shape");
	}

	void setWidth(int w)
	{
		width = w;
	}
	void setHeight(int h)
	{
		height = h;
	}
	virtual void print()
	{
		cout<<"This is shape"<<endl;
	}

	// 构造函数
	Shape():width(0),height(0)
	{
		cout<<"This Shape is constructed."<<endl;
	}

	// 父类析构函数申明为虚函数
	virtual ~Shape()
	{
		cout<<"This Shape is destroyed."<<endl;
	}
};

// 接口类，仅包含纯虚函数，并且不包含其他任何成员与方法
// 无法进行实例化
class PaintMethod
{
public:
	virtual void getCube()=0;
	virtual void getPencil()=0;
	virtual void getBlank()=0;
};

// 基类 PaintCost，抽象类;无法进行实例化
class PaintCost
{
public:
	int getCost(int area)
	{
		return area * 70;
	}

	// 声明一个纯虚函数
	virtual void getCube() =0;
};


// 还有一种所有方法均public给外界调用的叫啥...给忘了，集成类？？


// 派生类
class Rectangle: public Shape, public PaintCost
{
private:
	Point2i startPt;
	Point2i endPt;
public:
	int getArea()
	{
		return (width * height);
	}
	void print()
	{
		cout<<"This is Rectangle"<<endl;
	}

	// 继承了抽象类的纯虚函数，则必须将所有纯虚函数均实现才可以实例化
	void getCube()
	{
		cout<<"Just test for pure_virtual_class."<<endl;
	}

	// 子类构造函数
	Rectangle()
	{
		cout<<"This Rectangle is constructed."<<endl;
	}

	// 子类析构函数
	~Rectangle()
	{
		cout<<"This Rectangle is destroyed."<<endl;
	}
};

int main(void)
{
	// 1.构造函数
	cout<<"------ Shape constructor func ------"<<endl;
	Shape *shape = new Shape();
	cout<<"------ Rectangle constructor func ------"<<endl;
	Rectangle *rectangle = new Rectangle();

	// 1.1 调用自身打印
	cout<<"------ Self print ------"<<endl;
	cout<<"Shape print: ";
	shape->print();
	cout<<"Rectangle print: ";
	rectangle->print();

	// 1.2 类的静态成员与静态方法,通过::获取
//	Shape::ShapeName = "I'm BJTUer.";
//	cout<<Shape::ShapeName<<endl;
//	Shape::shapePrint();

	// 2 动态多态打印
	cout<<"------ Dynamic constructor func ------"<<endl;
	Shape *shape1 = new Rectangle();
	cout<<"------ Dynamic bind print ------"<<endl;
	shape1->print();

	// 3 调用析构函数
	cout<<"------ shape destructor func------"<<endl;
	delete shape;
	cout<<"------ rectangle destructor func------"<<endl;
	delete rectangle;
	cout<<"------ shape1 destructor func------"<<endl;
	delete shape1;

	return 0;
}

/* 总结：
 * 1) 虚函数原理：虚表指针与虚函数表
 * 2) 构造函数：先基类，再派生类的成员，再调用派生类构造函数
 * 3) 析构函数：先调用子类析构函数，再调用父类析构函数
 * 4) 纯虚函数-->接口类，抽象类
 * */
 

测试结果如下：

总结

1. 虚函数原理：虚表指针与虚函数表

2. 构造函数：先基类，再派生类的成员，再调用派生类构造函数

3. 析构函数：先调用子类析构函数，再调用父类析构函数

4. 纯虚函数–>接口类，抽象类

答案

构造函数不可以是虚函数，而析构函数可以且常常是虚函数。

原因

1、构造函数不可以是虚函数

当类中声明虚函数时，编译器会在类中生成一个虚函数表，虚函数表是一个存储成员函数指针的数据结构。

虚函数表是由编译器自动生成与维护的，virtual成员函数会被编译器放入虚函数表中，当存在虚函数时，每个对象都有一个指向虚函数的指针（vptr指针）。在实现多态的过程中，父类和派生类都有vptr指针。

vptr的初始化：当对象在创建时，由编译器对 vptr 指针进行初始化。在定义子类对象时，vptr 先指向父类的虚函数表，在父类构造完成之后，子类的 vptr 才指向自己的虚函数表。

如果构造函数时虚函数，那么调用构造函数就需要去找vptr，而此时 vptr 还没有初始化。

因此，构造函数不可以是虚函数。

2、析构函数常常是虚函数

与构造函数不同，vptr 已经完成初始化，析构函数可以声明为虚函数，且类有继承时，析构函数常常必须为虚函数。

比如下面的例子：

#include <iostream>
using namespace std;

class base
{
public:
    base()
    {
        cout << "base constructor" << endl;
    }
    virtual ~base()
    {
        cout << "base destructor" << endl;
    }
};

class derived : public base
{
public:
    derived()
    {
        cout << "derived constructor" << endl;
    }
    virtual ~derived()
    {
        cout << "derived destructor" << endl;
    }
};

int main()
{
    base *pBase = new derived;
    cout << "---" << endl;
    delete pBase;

    return 0;
}

运行结果为：

若析构函数不是虚函数，则运行结果为：

可以看出：

• 若析构函数是虚函数，delete 时，基类和子类都会被释放；
• 若析构函数不是虚函数，delete 时，只有基类会被释放，而子类没有释放，存在内存泄漏的隐患。

详情请看这里。

转载于：https://zhuanlan.zhihu.com/p/255274039

（SAW：Game Over！）