delete何时开始生效。

renstone921

本来我认为当对一个使用new分配的变量进行delete后,该变量就应当立即失效了.但使用以下的代码作测试,结果却不是我所预期的.

1. 
   
2. #include <iostream>;
   
3. 
   
4. using namespace std;
   
5. 
   
6. class Cat
   
7. {
   
8. public:
   
9.         Cat()
   
10.         {
    
11.                 cout << "\n Cat Constructs\n";
    
12.         }
    
13. 
    
14.         ~Cat()
    
15.         {
    
16.                 cout << "\n Cat Destructs\n";
    
17.         }
    
18. 
    
19.         void sleep()
    
20.         {
    
21.                 cout << "\nI'm sleeping\n";
    
22.         }
    
23. 
    
24.         void speek()
    
25.         {
    
26.                 cout << "\nMEOW!\n";
    
27.         }
    
28. 
    
29.         void eat()
    
30.         {
    
31.                 cout << "\nWhere is the mouse!\n";
    
32.         }
    
33. };
    
34.        
    
35. 
    
36. int main()
    
37. {
    
38.         Cat* cat = new Cat();
    
39.         if (NULL == cat)
    
40.                 return -1;
    
41.         delete cat;
    
42.         cat->;eat();                //Works;
    
43.         return (0);
    
44. }
    

复制代码

输出:
Cat Constructs

Cat Destructs

Where is the mouse!
有兄弟能帮我解释一下吗?

luojiannx

估计delete cat只是调用了析构函数, 而析构函数一般用来释放资源
但是cat指针仍然在程序里面
并没有如你所愿变成NULL(cat 并不是malloc分派空间)
所以仍然可以调用,但是不能访问已经释放掉的资源
你没申请什么资源, 所以应该就是你看到的样子

蓝白725

你如果在Cat类中加一个数据成员，并在构造函数中将其赋个初值，然后，在delete之后看看那个数据成员的值就会发现delete的效果了。
不管是delete还是free，都不会将指针置为NULL，所以，良好的习惯是在delete或free或立即将指针置为NULL，否则就会有野指针的问题了。

renstone921

1. 
   
2. #include <iostream>;
   
3. 
   
4. using namespace std;
   
5. 
   
6. class Cat
   
7. {
   
8. public:
   
9.         Cat(int val)
   
10.         {
    
11.                 value = val;
    
12.                 cout << "\n Cat Constructs\n";
    
13.         }
    
14. 
    
15.         ~Cat()
    
16.         {
    
17.                 cout << "\n Cat Destructs\n";
    
18.         }
    
19. 
    
20.         void sleep()
    
21.         {
    
22.                 cout << "\nI'm sleeping\n";
    
23.         }
    
24. 
    
25.         void speek()
    
26.         {
    
27.                 cout << "\nMEOW!\n";
    
28.         }
    
29. 
    
30.         void eat()
    
31.         {
    
32.                 cout << "\nWhere is the mouse!\n";
    
33.         }
    
34. private:
    
35.         int value;                       
    
36. };
    
37.        
    
38. 
    
39. int main()
    
40. {
    
41.         Cat* cat = new Cat(10);
    
42.         if (NULL == cat)
    
43.                 return -1;
    
44.         delete cat;
    
45.        
    
46.         int* tmp = new int[100000];
    
47.         if (NULL ==tmp)
    
48.                 return (-1);
    
49.         *tmp = 100;
    
50.         delete []tmp;
    
51.         cat->;eat();                //Works;
    
52.         return (0);
    
53. }
    
54. 
    

复制代码

修改后结果:

Cat Constructs

Cat Destructs

Where is the mouse!
我也知道应当是无效的,但不知怎么会出现这种结果.会不会是因为这是在C++中没有定义的行为.

gvim

改成下面再试试
  void eat()
   {
      value++;
      cout << "\nWhere is the mouse!\n";
   }

renstone921

还是一样

gvim

不好意思，是我大意看错了。我说成以前遇到的情况了：

1. 
   
2. #include <iostream>;
   
3. using namespace std;
   
4. class Cat
   
5. {
   
6.         public:
   
7.                 void eat()
   
8.                 {
   
9.                                                 //value++;     //this is the fault
   
10.                         cout << "\nWhere is the mouse!\n";
    
11.                 }
    
12.         private:
    
13.                 int value;         
    
14. };
    
15. int main()
    
16. {
    
17.         Cat* cat;
    
18.         cat->;eat();      //Works;
    
19.         return (0);
    
20. }

复制代码

你说的情况，还真是如你所说，，，一会想想看。

mq110

野指针.

BabyBlue

delete成功后只是给那块内存做个可以回收的标记，并不马上清空。
你通过原来的指针还是可以看到里面的东东，就像你写的那些。
反正我们通常做法是， delete后马上把指向原来的那块内存的指针赋Null