异常时对对象的清理，在栈中和堆中不一样么？

firecityplans

1. #include <iostream>
   
2. 
   
3. using namespace std;
   
4. 
   
5. class Trace {
   
6.         static int counter;
   
7.         int objid;
   
8. 
   
9. public:
   
10.         Trace() {
    
11.                 objid= counter++;
    
12.                 cout << "constructing Trace #" << objid << endl;
    
13.                 if( objid == 3 ) throw 3;
    
14.         }
    
15. 
    
16.         ~Trace() {
    
17.                 cout << "destructing Trace #" << objid << endl;
    
18.         }
    
19. };
    
20. 
    
21. int Trace:: counter = 0;
    
22. 
    
23. int main() {
    
24.         try{
    
25.                 Trace n1 ;
    
26. 
    
27.                 Trace array[5];
    
28. 
    
29.                 /*Trace *n1 = new Trace;
    
30. 
    
31.                 Trace *array = new Trace[5];*/
    
32. 
    
33.                 Trace n2; // won't get here
    
34.         }
    
35.         catch( int i){
    
36.                 cout << " caught" << i << endl;
    
37.         }
    
38. }

复制代码

打印日志如下
constructing Trace #0
  constructing Trace #1
  constructing Trace #2
  constructing Trace #3
  destructing Trace #2
  destructing Trace #1
  destructing Trace #0
  caught3
  请按任意键继续. . .

此方式下n1对象可以被销毁，而如下

1. class Trace {
   
2.         static int counter;
   
3.         int objid;
   
4. 
   
5. public:
   
6.         Trace() {
   
7.                 objid= counter++;
   
8.                 cout << "constructing Trace #" << objid << endl;
   
9.                 if( objid == 3 ) throw 3;
   
10.         }
    
11. 
    
12.         ~Trace() {
    
13.                 cout << "destructing Trace #" << objid << endl;
    
14.         }
    
15. };
    
16. 
    
17. int Trace:: counter = 0;
    
18. 
    
19. int main() {
    
20.         try{
    
21.                
    
22.                 Trace *n1 = new Trace;
    
23. 
    
24.                 Trace *array = new Trace[5];
    
25. 
    
26.                 Trace n2; // won't get here
    
27.         }
    
28.         catch( int i){
    
29.                 cout << " caught" << i << endl;
    
30.         }
    
31. }

复制代码

打印的日志如下：
constructing Trace #0
  constructing Trace #1
  constructing Trace #2
  constructing Trace #3
  destructing Trace #2
  destructing Trace #1
  caught3

即n1没有被销毁，是何缘故？
因为一个分配在栈中，一个分析在堆中引起？

赐教！

zhengy88

这是编译的事情，栈在离开时会调用析构函数。堆中是程序员自己决定，编译器不知道你什么时候不需要这个玩意了