指针容器的清理

在STL中经常用容器存储指针，在存储后需要delete指针。

刚开始的时候我是这么用：

vector<path*> p;  
for(int i=0;i<100;i++)  
    p.push_back(new path);  
for(size_t i=0;i<100;i++)  
   {
     delete p[i];  
     p[i] = null;
   }

       或
         vector<path>::iterator it = p.begin();  
 for(;it!=p.end();++it)  
{  
   delete *it; 
    *it = null;

} 

后来 创建 vector的指针容器多了，就要大量写这么多的重复语句，只好自己写个专门的处理类。Clean

[cpp]  view plain copy

1. #include <vector>
   #include <list>
   #include <queue>
   #include <map>
   
2. 
   
3. class Clean{  
4. public:  
5.     template<class T >  
6.     static void Clear(vector<T*> &c)  //引用
7.     {  
8.         size_t size= c.size();  
9.         for (size_t i =0 ;i<size ;i++)  
10.         {  
11.             if(c[i])  
12.             delete c[i];  
13.             c[i] = null;
14.         }  
15.         c.clear();  
16.     }  
17. 
    
18.     template<class T >  
19.     static void Clear(list<T*>& c)  
20.     {  
21.         size_t size= c.size();  
22.         for (size_t i =0 ;i<size ;i++)  
23.         {  
24.             if(c[i])  
25.                 delete c[i];  
26.         }  
27.         c.clear();  
28.         c[i] = null;
    
29.     }  
30. 
    
31.     template<class T >  
32.     static void Clear(deque<T*>& c)  
33.     {  
34.         size_t size= c.size();  
35.         for (size_t i =0 ;i<size ;i++)  
36.         {  
37.             if(c[i])  
38.            delete c[i];  
39.             c[i] = null;
    
40.         }  
41.         c.clear();  
42.     }  
43. 
    
44.     template<class T,class _T>  
45.     static void Clear(map<T,_T*>& c)  
46.     {  
47.         map<T,_T*>::iterator it = c.begin();  
48.         for(;it!=c.end();it++)  
49.         {  
50.             delete it.second;  
51.         }  
52.     }  
53.   
54. };  

有个这个类，OK ！

[cpp]  view plain copy

1. vector<path*> p;  
2. for(int i=0;i<100;i++)  
3.     p.push_back(new path);  
4. Clean::Clear<path>(p);