自動析構時是先析構後構造的.

//普通(非模板)類的成員模板
class DebugDelete{
public:
 DebugDelete(ostream &s = cerr) :os(s){}
 template <typename T>void operator()(T*p)const
 {
 os << "deleting unique_ptr " <<typeid(T).name() <<endl;
 delete p;
 }
private:
 ostream &os;
};
void demo_general_class_tempalte_member()
{
 double *p = new double;
 DebugDelete d;
 d(p);//d呼叫DebugDelet::operator()(double*),釋放p
 int* ip = new int;
 //在一個臨時DebugDelete 物件上呼叫operator()(int*)
 DebugDelete()(ip);
 //例項化DebugDelete::opeartor()<int>(int*)const
 unique_ptr<int,DebugDelete>p2(new int,DebugDelete());
 //例項化DebugDelete::opeartor()<string>(string*)const
 unique_ptr<string,DebugDelete>sp(new string,DebugDelete());
}

這裡輸出

deleting unique_ptr double
deleting unique_ptr int
deleting unique_ptr class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >
deleting unique_ptr int

可以看到,主動析構的正常進行.

函式結束後自動析構的,先建立了int後建立了string,但是先析構了string

class B
{
public:
 virtual ~B(){ cout << "delete B" << endl; }
};
class D :B
{
public:
 virtual ~D() override{ cout << "delete D" << endl; }
};
void demo_delete()
{
 D d;
}

輸出

delete D

delete B

這裡構造時是先構造基類,再構造派生類.但是在析構時是先析構了子類,再析構了基類。

知識點補充：C++ 構造與析構的執行順序

1、程式碼如下：

class A
{
public:
 int _Id; 
 A():_Id(0)
 {
 printf("A[%d]\n",_Id);
 }

~A()
 {
 printf("~A[%d]\n",_Id);
 }
};

class B
{
public:
 A _A;
 A* _PA;
 B()
 {
 printf("B\n");
 }
 ~B()
 {
 printf("~B\n");
 delete _PA;
 }
};

int main(int argc,char* argv[])
{
 {
 B b;
 b._PA = new A();
 b._PA->_Id = 17;
 }

 return 0;
}

2、執行順序

A[0]
B
A[0]
~B
~A[17]
~A[0]

3、B是棧上物件，C++保證棧上物件離開作用域，會自動呼叫析構方法。

4、考慮b中的物件，_A是棧上物件，_PA是指標，堆上物件，對於_PA必須delete，否則資源洩露。而對於_A不需要處理，會自動呼叫析構方法。可以這樣理解，物件b離開作用域，呼叫析構方法，而b中的_A當然也離開了作用域（皮之不存毛將存焉），呼叫析構方法。

5、碰到過這樣的情況，vs自動生成的析構方法有問題，導致崩潰。手動新增一個析構方法，就可以了。

總結

到此這篇關於C++自動析構時的順序的文章就介紹到這了,更多相關C++自動析構時的順序內容請搜尋我們以前的文章或繼續瀏覽下面的相關文章希望大家以後多多支援我們！