构造与析构_using namespace std; class t{ static int count; pu-CSDN博客

本文链接：https://blog.csdn.net/Fakerw/article/details/126800114

本文通过C++代码示例探讨了构造函数与析构函数在父类与子类之间的调用关系，以及动态内存管理和多态的影响。在多态情况下，如果子类含有堆区分配的属性，父类指针删除时无法调用子类析构。同时，析构函数可以是虚函数，但构造函数不能。另外，指针操作如*p++和(*p)++的执行顺序也进行了说明。

摘要由CSDN通过智能技术生成

选择题

构造函数析构函数

#include <bits/stdc++.h>
using namespace std;
class T
{  

   static int count ;
   public : 
   T(int i=0) { count ++;  cout << "#"; }
   T(T&p)  {count++; cout << "&"; }
    ~T()   {count--; cout<< count <<"*";}
} ;
int T::count =0;
int main(int argc, char  *argv[])
{
   T *p = new T[5]; //5次构造
   delete []p;    //5次析构
   p = new T;     //1次构造
   T *q = new T(*p); //1次拷贝构造
   delete p;       //1次析构
   delete q;        //1次析构
   return 0; 

}

运行结果

#####4*3*2*1*0*#&1*0*

考察父类与子类的构造与析构关系

class B
{
   public:
   B() {cout << "B";} 
   ~B() {cout << "*";}
};

class D:public B
{
   public: 
   D(){ p = new int(0);cout << "D";}
   ~D() { cout << "#"; delete p ;}

   private:
   int * p;
};


class C: public D
{
   public:
      C() { q = new int(1);cout << "C";}
      ~C() {cout << "&"; delete q;}
   private :
      int * q;
};


 int main (int argc , char ** argv)
 { 
     B *b1 = new D();
     delete b1; //只会调用父类的析构函数
     B *b2 = new C();
     delete b2; //只会调用父类的析构函数
    //运行到此处的结果   BD*BDC* 
   
  
     C a;     //先调用子类的析构函数，在调用父类的析构函数
    //运行到此处的结果   BD*BDC*BDC&#* 
     return 0;
 }

**
本题获得结论：

多态使用时，如果子类中有属性开辟到堆区，那么父类指针在释放时候无法调用子类的析构。于是便有了虚析构或者纯虚析构

引申

既然析构函数可以是虚函数，那么构造函数可以是虚函数么？

答案： 不可以
原因：因为虚函数存在的唯一目的是为了多态。而子类并不继承父类的构造函数。构造函数是创建对象时自己主动调用的，不可能被继承。

静态函数可以是虚函数么？
答案： 不可以 。
原因：静态函数不属于任何对象，所以即使加上virtual 也是没有任何意义的

指针

    int a[] = {1,2,3} , *p =a;
    *p ++ =5;  // *p ++   先执行 *P = 5 ;即 a[0]= 5 随后p自加指向 a[1];
    (*p)++;  // 先取 *p ，再让*p这个值加1；
    cout <<a[0] << a[1] <<a[2] <<endl;// 5 3 3