使用指针容器后请销毁指针

把指针放入标准容器后,不要忘了在销毁容器时释放容器中指针所指向的object,否则"memory leak"
例如:

[cpp]  view plain copy

1. class CObj  
2. {  
3. ...  
4. };  
5. std::vector<CObj *> objVector(3);  
6. objVector.push_back(new CObj);  
7. objVector.push_back(new CObj);  
8. objVector.push_back(new CObj);  

当objVector容器被销毁时,该容器所存放的 3 个CObj被遗忘了,没有被释放.
因为objVector只知道去释放它所管理的对象,而对指针这个对象能干什么呢?指针本身就象int, long, double
一样,没有什么好释放的,要释放的是指针所指向的对象.很遗憾,标准容器,即std namespace空
间中容器,如vector, list, queue, map等都无法感知这一点.
要避免memory leak,你必须手工完成释放．象下面那样：

[cpp]  view plain copy

1. for(  
2.     std::vector<CObj *>::iterator i = objVector.begin();  
3.     i != objVector.end();  
4.     ++i  
5. )  
6. {  
7.     delete *i;  
8. }  

在这么简单的例子中你当然不会忘记，但在成千上万行的代码中呢，你会忘吗?
当然要让标准容器承担起管理资源的责任，只有把object本身存放入标准容器,标准容器才能承
担起释放object的责任．
例如：

[cpp]  view plain copy

1. class CObj  
2. {  
3. ...  
4. };  
5. std::vector<CObj> objVector(3); //看到没，放入容器的是CObj, 而不是CObj *  
6. objVector.push_back(*(new CObj));  
7. objVector.push_back(*(new CObj));  
8. objVector.push_back(*(new CObj));  

这就没有memory leak了.即当放入标准容器的是object本身时，programmer就不需要再为object
的析构而烦恼了．那为什么还有programmer要把object的指针放入标准容器呢？这些programmer
不是自寻烦恼吗?这些programmer并不是傻瓜，当然知道放入object的好处，但享有好处的同时，
你必须承担"坏处"---拷贝带来的资源浪费.


我们看下面的例子，到底把object放入容器的代价是什么.

[cpp]  view plain copy

1. #include <iostream>  
2. #include <vector>  
3. class A  
4. {  
5. public:  
6. A()  
7. {  
8.   std::cout << __FUNCTION__ << std::endl;  
9. }  
10. A(const A& other)  //复制函数  
11. {  
12.   std::cout << "copy ctor" << std::endl;  
13. }  
14. ~A()  
15. {  
16.   std::cout << __FUNCTION__ << std::endl;  
17. }  
18. };  
19. int main()  
20. {  
21.  {  
22.    std::cout << "standard container" << std::endl;  
23.    std::vector<A> obj2(3);  
24.    obj2.push_back(*(new A));  
25. }  
26.   return 0;  
27. }   

看看输出:
standard container
A::A
copy ctor
copy ctor
copy ctor
A::~A
A::A
copy ctor
copy ctor
copy ctor
copy ctor
A::~A
A::~A
A::~A
A::~A
A::~A
A::~A
A::~A


初始化只放进3个默认值，然后加进一个对象，按理只有4个构造，1个析构。
怎么会有那么多的构造，析构呢？
没办法，标准容器在你的视野外会大量的应用"copy"--拷贝的语意，只要它觉得需要．
我们设想一下，如果class A是一个重量级的class,即copy动作是非常耗时的，那这种方法是何等的低效．而如果标准容器内存放的是类似指针，int, long, double等这一类轻量级的class(为什么不能把内建类型视为class呢?),则copy动作的代价是完全可以忽略的．这就是那些programmer为什么选择在标准容器中存放指向object的指针的原因．
　
对比看看：使用指针容器

[cpp]  view plain copy

1. #include <iostream>  
2. #include <string>  
3. #include <vector>  
4.   
5.   
6. using namespace std;  
7.   
8.   
9. class A  
10. {  
11. public:  
12. A()  
13. {  
14. std::cout << __FUNCTION__ << std::endl;  
15. }  
16.   
17.   
18. A(const A& )    //复制构造函数  
19. {  
20. std::cout << "copy ctor" << std::endl;  
21. }  
22.   
23.   
24. ~A()  
25. {  
26. std::cout << __FUNCTION__ << std::endl;  
27. }  
28. };  
29.   
30.   
31. int main()  
32. {  
33. {  
34. std::cout << "standard container" << std::endl;  
35. A a1;  
36. std::vector<A*> obj2(3);   
37. obj2.push_back(&a1); //放入3个object  
38. }  
39. return 0;  
40. }   

结果：
A::A
A::~A


故在使用容器指针时：＂不要忘了在销毁容器时释放容器中指针所指向的object＂.