C++核心——多态里的构造和析构函数
一、构造函数和析构函数
对象的初始化和清理也是两个非常重要的安全问题
一个对象或者变量没有初始状态，对其使用后果是未知
同样的使用完一个对象或变量，没有及时清理，也会造成一定的安全问题
c++利用了构造函数和析构函数解决上述问题，这两个函数将会被编译器自动调用，完成对象初始化和清理工作。
对象的初始化和清理工作是编译器强制要我们做的事情，因此如果我们不提供构造和析构，编译器会提供
编译器提供的构造函数和析构函数是空实现。
- 构造函数：主要作用在于创建对象时为对象的成员属性赋值，构造函数由编译器自动调用，无须手动调用。
- 析构函数：主要作用在于对象销毁前系统自动调用，执行一些清理工作。
#include <iostream>
using namespace std;
class Test
{
public:
Test();
~Test();
};
Test::Test()
{
cout << "constructor" << endl;
}
Test::~Test()
{
cout << "destructor" << endl;
}
int main()
{
Test t;
return 0;
}
******************运行结果************************
PS F:\C_CPP\CPP_study> g++ .\test.cpp
PS F:\C_CPP\CPP_study> .\a.exe
constructor
destrtor
PS F:\C_CPP\CPP_study>
二、继承时构造函数和析构函数的执行过程
构造函数：先执行父类构造函数后执行子类构造函数。
析构函数：先执行子类析构函数再执行父类析构函数。
<u>有点像栈区的顺序，先进后出。创建类时先把父类push进去，所以先执行父类的构造函数，再把子类PUSH进去，所以再执行子类的构造函数。释放的时候子类在上面，所以先被POP出来，所以先执行子类的析构函数，再POP父类时执行父类的析构函数。</u>
#include <iostream>
#include <string>
using namespace std;
class Base
{
public:
string name;
int age;
virtual void getInfo() = 0;
Base()
{
cout << "Base's constructor" << endl;
}
~Base()
{
cout << "Base's destructor" << endl;
}
};
class Son : public Base
{
public:
Son(string name, int age);
virtual void getInfo();
~Son();
};
Son::Son(string name, int age)
{
cout << "son's constructor" << endl;
this->name = name;
this->age = age;
}
void Son::getInfo()
{
cout << "name: " << this->name <<
" \tage: " << this->age << endl;
}
Son::~Son()
{
cout << "son's destructor" << endl;
}
void test1()
{
Son *pson = new Son("tom", 20);
pson->getInfo();
delete pson;
}
int main()
{
test1();
return 0;
}
**********************执行结果*********************************
PS F:\C_CPP\CPP_study> g++ .\01_虚析构函数.cpp
PS F:\C_CPP\CPP_study> .\a.exe
Base's constructor # 先执行父类构造
son's constructor # 再执行子类构造
name: tom age: 20
son's destructor # 先执行子类析构
Base's destructor # 再执行父类析构
PS F:\C_CPP\CPP_study>
三、多态时的执行顺序
这个重点，先上代码
#include <iostream>
#include <string>
using namespace std;
class Base
{
public:
string name;
int age;
virtual void getInfo() = 0;
Base()
{
cout << "Base's constructor" << endl;
}
~Base()
{
cout << "Base's destructor" << endl;
}
};
class Son : public Base
{
public:
Son(string name, int age);
virtual void getInfo();
~Son();
};
Son::Son(string name, int age)
{
cout << "son's constructor" << endl;
this->name = name;
this->age = age;
}
void Son::getInfo()
{
cout << "name: " << this->name <<
" \tage: " << this->age << endl;
}
Son::~Son()
{
cout << "son's destructor" << endl;
}
void test2()
{
Base *p = new Son("jack", 22);
p->getInfo();
delete p;
}
int main()
{
test2();
return 0;
}
*****************************执行结果***********************************
PS F:\C_CPP\CPP_study> g++ .\01_虚析构函数.cpp
PS F:\C_CPP\CPP_study> .\a.exe
Base's constructor # 先执行父类构造
son's constructor # 再执行子类构造
name: tom age: 20
Base's destructor # 再执行父类析构
PS F:\C_CPP\CPP_study>
看出设么区别了么，和上已个代码相比，这里执行了父类的析构函数，可是子类的构造函数并没有执行。为什么会这样呢，接着从代码的区别着手分析
void test1()
{
Son *pson = new Son("tom", 20);
pson->getInfo();
delete pson;
}
************************************************
void test2()
{
Base *p = new Son("jack", 22);
p->getInfo();
delete p;
}
其实两套代码的区别就是这个函数的不同，具体到函数就成了函数体的第一条语句的不同。在test1中创建的是Son类型的指针，所以在delete的时候删除的是Son类型指针，那么肯定会执行Son的析构函数，可是test2中创建的是Base类型指针，所以在delete是删除的是Base类型的指针，而Son虽然继承了Base，但是却没有重写Base的析构函数，所以执行不到Son里面去，也就无法执行Son的析构函数，因为压根儿delete的就不是Son指针。如果是这样的话，那么就会带来一个很严重的问题，那就是如果Son类中含有堆取开辟的空间需要在析构函数中释放，就会导无法释放，造成内存泄漏。
一种致命警告⚠️
class Base
{
public:
string name;
int age;
virtual void getInfo() = 0;
Base()
{
cout << "Base's constructor" << endl;
}
};
如以上代码，将Base类定义为这个样子父类未定义析构函数时会造成警告，但是这个警告有的时候会导致程序无法正常运行下去，这个问题在我写一个小项目时曾发生过，因为父类没有析构函数体，变异时只有警告，但是运行时，就是执行完这个语句后无法继续执行后面的语句，所以这里提醒各位遇到这种提示警告最好马上解决，毕竟提示信息也很明显
warning: delete called on 'Base' that is abstract but has non-virtual destructor [-Wdelete-non-virtual-dtor]
delete p;
^
1 warning generated.
为了解决上述问题，需要使用多天的动态绑定特效
静态绑定：编译时绑定，通过对象调用
动态绑定：运行时绑定，通过地址实现
为了实现动态绑定，所以需要将父类的析构函数定义成虚函数，从而使调用父类西沟函数时动态绑定到子类的析构函数上。当然这里编译器还帮我们干了一件事，就是编译器把父类的析构函数数和子类的析构函数进行了一个绑定，因为正常情况下，只有子类重写了父类函数才会被动态绑定，但是这里虽然两个析构函数名都不一样，但是仍然能动态绑定，这就是编译器进行的一种绑定。
#include <iostream>
#include <string>
using namespace std;
class Base
{
public:
string name;
int age;
virtual void getInfo() = 0;
Base()
{
cout << "Base's constructor" << endl;
}
virtual ~Base()
{}
};
class Son : public Base
{
public:
Son(string name, int age);
virtual void getInfo();
~Son();
};
Son::Son(string name, int age)
{
cout << "son's constructor" << endl;
this->name = name;
this->age = age;
}
void Son::getInfo()
{
cout << "name: " << this->name <<
" \tage: " << this->age << endl;
}
Son::~Son()
{
cout << "son's destructor" << endl;
}
void test1()
{
Son *pson = new Son("tom", 20);
pson->getInfo();
delete pson;
}
void test2()
{
Base *p = new Son("jack", 22);
p->getInfo();
delete p;
}
int main()
{
test2();
return 0;
}
**************************执行结果*****************************
PS F:\C_CPP\CPP_study> g++ .\01_虚析构函数.cpp
PS F:\C_CPP\CPP_study> .\a.exe
Base's constructor
son's constructor
name: jack age: 22
son's destructor
PS F:\C_CPP\CPP_study>
从代码的运行结果来看，成功调用的子类的的虚构函数，如果子类中有堆区的数据，就可以正常在析构函数中释放。有人看到这里可能会有疑问，那父类的析构没有执行怎么办？这个问题完全不用担心，因为一般在实现多台的时候，父类被定义为抽象类，无法实例化对象，内部函数都别子类重写，调用的时候实质是在调用子类的函数。
四、总结
其实这篇博文是在我做一个小项目时遇到上面的警告，没有在意，导致程序无法运行，然后查资料并总结出来的。这里总结一句，就是在实现多态的时候，定义抽象父类的时候记得定义虚析构函数，养成这个习惯，每次定义多态的父类时顺手就把析构定义成虚函数就可以，可以省去很多不必要的麻烦。
