写了一个变态模板,对模板有兴趣的可以看看.

hatname

1. 
   
2. #pragma warning(disable:4786)
   
3. #include <conio.h>;
   
4. #include <iostream>;
   
5. #include <string>;
   
6. #include <list>;
   
7. #include <map>;
   
8. #include <vector>;
   
9. #include <algorithm>;
   
10. #include <functional>;
    
11. using namespace std;
    
12. 
    
13. template <class _T>;
    
14. 
    
15. struct empty_op
    
16. {
    
17.         void operator()(_T val){}
    
18. };
    
19. 
    
20. template<class _T1,class _T2=empty_op<_T1>; >;
    
21. struct clear_obj_1d
    
22. {
    
23.         _T2 _op;
    
24.         void operator()(_T1 p)
    
25.         {
    
26.                 _op(p);
    
27.                 delete p;
    
28.         }
    
29. };
    
30. 
    
31. template<class _T1,class _T2=empty_op<_T1>; >;
    
32. struct clear_obj_2d{
    
33.         _T2 _op;
    
34.         void operator()(_T1 val)
    
35.         {
    
36.                 _op(val);
    
37.                 delete val.second;
    
38.         }
    
39. };
    
40. 
    
41. template<class _T1,class _T2>;
    
42. struct clear_1d{
    
43.         void operator()(_T1 p)
    
44.         {
    
45.                 for_each(p->;begin(),p->;end(),_T2());
    
46.         }
    
47. };
    
48. 
    
49. 
    
50. template<class _T1,class _T2>;
    
51. struct clear_2d{
    
52.         void operator()(_T1 p)
    
53.         {
    
54.                 for_each(p.second->;begin(),p.second->;end(),_T2());
    
55.         }
    
56. };
    
57. 
    
58. typedef list<int *>;                                int_p_l;
    
59. typedef list<int_p_l *>;                        int_p_l_p_l;
    
60. typedef list<int_p_l_p_l *>;                btl;
    
61. 
    
62. int main()
    
63. {
    
64.         btl l;
    
65.         for_each(l.begin(),l.end(),\
    
66.                 clear_obj_1d<btl::value_type,\
    
67.                         clear_1d<btl::value_type,\
    
68.                                 clear_obj_1d<int_p_l_p_l::value_type,
    
69.                                         clear_1d<int_p_l_p_l::value_type,
    
70.                                                 clear_obj_1d<int_p_l::value_type
    
71.                                                 >;
    
72.                                         >;
    
73.                                 >;
    
74.                         >;
    
75.                 >;());
    
76.         getch();
    
77.         return 0;
    
78. }
    
79. 
    

复制代码

hatname

1. 
   
2. int_p_l pl;
   
3.         pl.push_back(new int(2));
   
4.         pl.push_back(new int(24));
   
5.         pl.push_back(new int(3));
   
6.         for_each(pl.begin(),pl.end(),clear_obj_1d<int*>;());
   
7. 
   

复制代码

gooderfeng

头一次见。
那里用这个样子写，把一个循环写的这样复杂

hatname

为了BT嘛,呵呵,刚开始只是想写一个
  for_each(pl.begin(),pl.end(),clear_obj_1d<int*>;());  这样的东西.

但是后来想到, 如果容器内部是指向另一个容器的指针,想看看有没有办法,用模板逐级释放.模板到是写了,就是调用比较费脑子.哈哈

gooderfeng

哈哈，那么多（）虫灾
佩服

albcamus

虽然看不懂，还是表示一下钦佩