C++实例说明为什么使用虚构造函数

C++实例说明为什么使用虚构造函数

编者：李国帅

时间：2020/01/13

背景原因:

这是个很久以前的例子，为了证明覆盖和隐藏的区别，验证为什么要使用虚构造函数。代码使用c++例子。

所需资源：

VC或其他编译器

问题相关：

如果使用虚构造函数virtual ~ClassA()。

如果使用普通构造函数~ClassC()。

例子1

例子2

完整代码:

#include "stdafx.h"
#include <iostream>
using namespace std;
class ClassA
{
public:
  ClassA()
  {
    cout << "ClassA" << endl;
  }
  virtual ~ClassA()
  {
    cout << "~ClassA" << endl;
  }
};
class ClassB :ClassA
{
public:
  ClassB()
  {
    cout << "ClassB" << endl;
  }
  ~ClassB()
  {
    cout << "~ClassB" << endl;
  }
};
class ClassC
{
public:
  ClassC()
  {
    cout << "ClassC" << endl;
  }
  ~ClassC()
  {
    cout << "~ClassC" << endl;
  }
};
class ClassD :ClassC
{
public:
  ClassD()
  {
    cout << "ClassD" << endl;
  }
  ~ClassD()
  {
    cout << "~ClassD" << endl;
  }
};

void deleteA()
{
  ClassA* pA = new ClassA();
  delete pA;
  /*
ClassA
~ClassA*/
}
void deleteB()
{
  ClassB* pB = new ClassB();
  delete pB;
  /*ClassA
ClassB
~ClassB
~ClassA*/
}

void deleteAB1()
{
  ClassB* pB = new ClassB();
  ClassA* pA = (ClassA*)pB;
  delete pA;//==  delete pB;
  cout << "-----" << endl;
  ClassB* pB1 = new ClassB();
  ClassA* pA1 = (ClassA*)pB1;
  delete pB1;
  //执行 delete pA; 如果 virtual ~ClassA() 输出 ClassA \n ClassB \n ~ClassB \n ~ClassA
  //原因是虚函数导致了隐藏，delete pA == delete pB;

  /*ClassA
ClassB
~ClassB
~ClassA
-----
ClassA
ClassB
~ClassB
~ClassA*/
}
void deleteAB2()
{
  ClassA* pA = new ClassA();
  ClassB* pB = (ClassB*)pA;
  delete pA;
  cout << "-----" << endl;
  ClassA* pA1 = new ClassA();
  ClassB* pB1 = (ClassB*)pA1;
  delete pB1;

  /*ClassA
~ClassA
-----
ClassA
~ClassA*/

}
void deleteC()
{
  ClassC* pC = new ClassC();
  delete pC;
  /*ClassC
~ClassC*/
}
void deleteD()
{
  ClassD* pD = new ClassD();
  delete pD;
  /*ClassC
ClassD
~ClassD
~ClassC*/
}

void deleteCD1()
{
  ClassD* pD = new ClassD();
  ClassC* pC = (ClassC*)pD;
  delete pC;
  cout << "-----" << endl;

  ClassD* pD1 = new ClassD();
  ClassC* pC1 = (ClassC*)pD1;
  delete pD1;
  //执行 delete pC; 输出 ClassC \n ClassD \n ~ClassC 导致~ClassD 没有执行
//执行 delete pD; 不管~ClassC()是否虚函数 输出 ClassC \n ClassD \n ~ClassD \n ~ClassC

/*ClassC
ClassD------------------~ClassD没有执行，它被覆盖掉
~ClassC
-----
ClassC
ClassD
~ClassD
~ClassC*/
}
void deleteCD2()
{
  ClassC* pC = new ClassC();
  ClassD* pD = (ClassD*)pC;
  delete pC;
  cout << "-----" << endl;
  ClassC* pC1 = new ClassC();
  ClassD* pD1 = (ClassD*)pC1;
  delete pD1;
  /*
  ClassC
~ClassC
-----
ClassC
~ClassD------------------ClassD没有实例产生
~ClassC*/
}
int main(int argc, char* argv[])
{
  deleteA();
  cout << "----------------------" << endl;
  deleteB();
  cout << "----------------------" << endl;
  deleteAB1();
  cout << "----------------------" << endl;
  deleteAB2();
  cout << "----------------------" << endl;

  deleteC();
  cout << "----------------------" << endl;
  deleteD();
  cout << "----------------------" << endl;
  deleteCD1();
  cout << "----------------------" << endl;
  deleteCD2();
  cout << "----------------------" << endl;

  //system("PAUSE");
  return 0;
}

运行结果：