为什么构造函数不可以被声明为虚函数而析构函数有时候必须声明为虚函数

最新推荐文章于 2021-06-01 14:33:45 发布

Hyacinth_Dy

最新推荐文章于 2021-06-01 14:33:45 发布

阅读量565

点赞数 2

文章标签： C++多态虚函数构造函数析构函数继承

本文链接：https://blog.csdn.net/jyy305/article/details/53140814

版权

一、为什么构造函数不可以被声明为虚函数

1.构造一个对象时必须知道一个对象的实际类型，而虚函数行为¹是在运行期间才确定其实际类型的，而构造对象时对象还未构造成功编译器无法知道对象的实际类型。

2.虚函数的执行依赖于虚函数表，而虚函数表是在构造函数中被初始化的，即让vptr指向正确的虚函数表，若将构造函数声明为虚函数，在构造对象期间虚函数表还没有被初始化，将无法进行。

虚函数：C++中的虚函数就是用来解决多态问题的，所谓虚函数就是在基类中声明函数是虚拟的，并不是实际存在的函数，然后再派生类中才正式定义此函数。

二、为什么析构函数有时候必须声明为虚函数

1.一般情况下：

#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
#include<stdlib.h>
using namespace std;
class Base
{
public:
Base(char *pStr = '\0')
{
if(NULL == pStr)
{
_pStr = new char[1];
*_pStr = '\0';
}
else
{
_pStr = new char[strlen(pStr)+1];
strcpy(_pStr,pStr);
}
cout<<"Base()"<<endl;
}
~Base()
{
if(NULL != _pStr)
{
delete[]_pStr;
_pStr = NULL;
}
cout<<"~Base()"<<endl;
}
private:
char * _pStr;
};
class Derived:public Base
{
public:
Derived(char *dStr = '\0')
{
if(NULL == dStr)
{
_dStr = new char[1];
*_dStr = '\0';
}
else
{
_dStr = new char[strlen(dStr)+1];
strcpy(_dStr,dStr);

}
cout<<"Derived()"<<endl;
}
~Derived()
{
if(NULL != _dStr)
{
delete[]_dStr;
_dStr = NULL;
}
cout<<"~Derived()"<<endl;
}
private:
char *_dStr;
};
void FunTest()
{
Derived *p = new Derived;//采用派生类指针或者引用操作派生类
delete p;
}
int main()
{
FunTest();
system("pause");
return 0;
}

这种情况下析构函数不是虚函数，在main函数中采用派生类的指针去操作派生类，是释放指针的过程是先释放派生类的资源再释放基类的资源。

2.第一种情况：

#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
#include<stdlib.h>
using namespace std;
class Base
{
public:
Base(char *pStr = '\0')
{
if(NULL == pStr)
{
_pStr = new char[1];
*_pStr = '\0';
}
else
{
_pStr = new char[strlen(pStr)+1];
strcpy(_pStr,pStr);
}
cout<<"Base()"<<endl;
}
~Base()
{
if(NULL != _pStr)
{
delete[]_pStr;
_pStr = NULL;
}
cout<<"~Base()"<<endl;
}
private:
char * _pStr;
};
class Derived:public Base
{
public:
Derived(char *dStr = '\0')
{
if(NULL == dStr)
{
_dStr = new char[1];
*_dStr = '\0';
}
else
{
_dStr = new char[strlen(dStr)+1];
strcpy(_dStr,dStr);

}
cout<<"Derived()"<<endl;
}
~Derived()
{
if(NULL != _dStr)
{
delete[]_dStr;
_dStr = NULL;
}
cout<<"~Derived()"<<endl;
}
private:
char *_dStr;
};
void FunTest()
{
Base *p = new Derived;//采用基类指针或者引用操作派生类
delete p;
}
int main()
{
FunTest();
system("pause");
return 0;
}

这种情况下析构函数不是虚函数，在main函数中采用基类的指针去操作派生类，由结果可以看出只调用了基类的析构函数释放了基类开辟的空间，没有调用派生类的析构函数释放派生类开辟的空间，造成了空间泄露。

在公有继承下，基类只能操作派生类中从基类继承下来的成员，如果想要对派生类中非继承成员进行操作，则成员函数在基类中应该声明为虚函数，为了解决这种基类指针或引用对派生类操作时造成空间泄露的问题应该将析构函数声明为虚函数。

第二种情况

#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
#include<stdlib.h>
using namespace std;
class Base
{
public:
Base(char *pStr = '\0')
{
if(NULL == pStr)
{
_pStr = new char[1];
*_pStr = '\0';
}
else
{
_pStr = new char[strlen(pStr)+1];
strcpy(_pStr,pStr);
}
cout<<"Base()"<<endl;
}
virtual ~Base()//基类析构函数声明为虚函数
{
if(NULL != _pStr)
{
delete[]_pStr;
_pStr = NULL;
}
cout<<"~Base()"<<endl;
}
private:
char * _pStr;
};
class Derived:public Base
{
public:
Derived(char *dStr = '\0')
{
if(NULL == dStr)
{
_dStr = new char[1];
*_dStr = '\0';
}
else
{
_dStr = new char[strlen(dStr)+1];
strcpy(_dStr,dStr);

}
cout<<"Derived()"<<endl;
}
~Derived()
{
if(NULL != _dStr)
{
delete[]_dStr;
_dStr = NULL;
}
cout<<"~Derived()"<<endl;
}
private:
char *_dStr;
};
void FunTest()
{
Base *p = new Derived;//采用基类对象或指针操作派生类
delete p;
}
int main()
{
FunTest();
system("pause");
return 0;
}