指针学习1new &delete & destructor

1. 一般指针的new&delete

对于指针a,delete a之后，指针a 的地址仍然是原来的地址(并不是NULL)，只不过所指向的对象被释放了，此时指针存放的值为随机的，由编译器确定。

 1     int *a = new int(2);
 2     cout << "after new :" << endl;
 3     cout << "a = " << a << "," << "*a = " << *a << endl;
 4
 5     delete a;
 6     cout << "after delete: " << endl;
 7     if(a == NULL)
 8     {
 9         cout << "a is null after delete" << endl;
10     }
11     else
12     {
13         cout << " a is not null after delete" << endl;
14     }
15     cout << "a = " << a << "," << "*a = " << *a << endl; 

//好的编程习惯
delete a;
a = NULL;

常规方法创建的对象，当实际对象（而不是对象的引用）超出作用域时，才会运行析构函数
动态方法创建的对象，当删除指向动态分配对象的指针时，才会运行析构函数。         

2. 一般类对象的声明与初始化：不用new也可以定义类对象（区别于java），默认调析构函数
注：为方便简单演示，并没有遵循三法则

 1class Stu
 2{
 3   public:
 4         Stu(int m):var(m)
 5          { 
 6                  var = m;
 7                  cout << "constructor called." << endl;
 8          }      
 9          ~Stu() { cout << var << " destructor called." << endl;}         
10   private:
11          int var;         
12};
13
14void func()
15{
16       //调用构造函数
17       Stu a(20);
18       //调用默认复制构造函数
19       Stu b(a);     
20       //等价于Stu temp(b); Stu b(temp);  
21       //所以有调用构造函数的过程
22       Stu c = 30;     
23       //都是用隐式方式定义的，所以不用delete,自动调用析构函数
24 |        //注意析构的顺序     
25}
26
27int main()
28{
29   func();   
30   return 0;
31}

这里有一个需要注意的地方，就是如果func里面的代码是直接写在main里的则不一定调用析构函数 ，由编译器决定。
上面是dev c++, 下面是vc6.0的运行结果

 1
 2int main()
 3{
 4
 5    //{
 6       //调用构造函数
 7       Stu a(20);
 8       //调用默认复制构造函数
 9       Stu b(a);     
10       //等价于Stu temp(b); Stu b(temp);  
11       //所以有调用构造函数的过程
12       Stu c = 30;     
13       //new出来的指针对象，必须显示delete,如a,b
14       //类对象结束局部范围后会自动调用析构函数 如c    
15    //}
16    return 0;
17}

3. 用new定义类对象,必须delete
动态分配的对象只有在指向该对象的指针被删除时才撤销。如果没有删除指向动态对象的指针，则不会运行该对象的析构函数，对象则一直存在，从而导致内存泄露。
常规方法创建的对象，当实际对象（而不是对象的引用）超出作用域时，才会运行析构函数
动态方法创建的对象，当删除指向动态分配对象的指针时，才会运行析构函数。

 1class Stu
 2{
 3   public:
 4         Stu(int m):var(m)
 5          { 
 6                  var = m;
 7                  cout << "constructor called." << endl;
 8          }      
 9          ~Stu() { cout << var << " destructor called." << endl;}         
10   private:
11          int var;         
12};
13
14void func()
15{
16       //调用构造函数
17       Stu* a = new Stu(20);
18       //调用默认复制构造函数
19       Stu* b= new Stu(*a);     
20       //等价于Stu temp = new Stu(30); Stu b(temp);  
21       //所以有调用构造函数的过程
22       Stu c = 30;     
23       //new出来的指针对象，必须显示delete,如a,b
24       //类对象结束局部范围后会自动调用析构函数 如c
25       delete a;
26       delete b;
27}
28
29int main()
30{
31   func();   
32   return 0;
33}

幸运草 2010-04-18 10:58 发表评论