看了《Effective C++》中提到的TR1::shared_ptr,觉得很有用，就想尝试自己实现一个。一开始的想法很直接，就是两个模板参数一个代表所持有的指针类型，一个代表销毁资源的函数类型，默认为delete操作，于是有了第一个版本

1. #ifndef SHARE_PTR_H_INCLUDED  
2. #define SHARE_PTR_H_INCLUDED  
3. namespace share_ptr  
4. {  
5.     template<class T,class Func=void>  
6.     class share_ptr  
7.     {  
8.     public:  
9.         size_t* pCount;  
10.         share_ptr(T* pt_,Func destoryFunc_):  
11.             pt(pt_),destoryFunc(destoryFunc_)  
12.             {  
13.                 pCount = new size_t(1);  
14.             }  
15.         share_ptr(const share_ptr&sp):  
16.             pt(sp.pt),destoryFunc(sp.destoryFunc)  
17.         {  
18.             pCount=sp.pCount;  
19.             (*pCount)++;  
20.         }  
21.         share_ptr& operator=(const share_ptr&sp)  
22.         {  
23.             release(); 
24.             pt = sp.pt;  
25.             destoryFunc = sp.destoryFunc;  
26.             pCount=sp.pCount;  
27.             (*pCount)++;  
28.             return *this;  
29.         }  
30.         ~share_ptr()  
31.         { 
32.             release(); 
33.         }  
34.         T& operator*()const  
35.         {  
36.             return *pt;  
37.         }  
38.         T* operator->()const  
39.         {  
40.             return pt;  
41.         }  
42.         T* get() const  
43.         {  
44.             return pt;  
45.         }  
46.     private:  
47.         T* pt;  
48.         Func destoryFunc;  
49.         void release() 
50.         { 
51.             *pCount)--; 
52.             if(*pCount == 0 )  
53.             {  
54.                 destoryFunc(pt);  
55.             } 
56.         } 
57.   
58.     };  
59.   
60. // 特化,省略销毁函数时,默认用delete  
61.   
62.     template<class T>  
63.     class share_ptr<T,void>  
64.     {  
65.     public:  
66.         typedef void (*freeFunc)(T* );  
67.         size_t* pCount;  
68.         share_ptr(T* pt_):  
69.             pt(pt_)  
70.             {  
71.                 pCount = new size_t();  
72.                 (*pCount)=1;  
73.             }  
74.         share_ptr(const share_ptr&sp):  
75.             pt(sp.pt)  
76.         {  
77.             pCount=sp.pCount;  
78.             (*pCount)++;  
79.         }  
80.         share_ptr& operator=(const share_ptr&sp)  
81.         {  
82.             release(); 
83.             pt = sp.pt;  
84.             pCount=sp.pCount;  
85.             (*pCount)++;  
86.             return *this;  
87.         }  
88.         ~share_ptr()  
89.         {  
90.             release(); 
91.         }  
92.         T& operator*()  
93.         {  
94.             return *pt;  
95.         }  
96.         T* operator->()  
97.         {  
98.             return pt;  
99.         }  
100.         T* get() const  
101.         {  
102.             return pt;  
103.         }  
104.     private:  
105.         T* pt;  
106.         void release() 
107.         { 
108.             (*pCount)--;  
109.             if(*pCount == 0 )  
110.             {  
111.                 delete pt;  
112.             }  
113.         } 
114.     };  
115. }  
116. #endif // SHARE_PTR_H_INCLUDED  

但是这个版本在要定义销毁函数时还需要声明销毁函数类型，用起来很麻烦，而且考虑到销毁函数只能有一个T*的参数，因此考虑将第二个模板参数定义为R，这样销毁函数可以用R (T*)来表示。于是有了第二个版本

1. #ifndef SHARE_PTR_H_INCLUDED 
2. #define SHARE_PTR_H_INCLUDED 
3. namespace share_ptr 
4. { 
5.     template<class T,class FreeFuncRetType=void> 
6.     class share_ptr 
7.     { 
8.     public: 
9.         typedef FreeFuncRetType(*FreeFuncType)(T*); 
10.         size_t* pCount; 
11.         template<class U> 
12.         share_ptr(U* pt_,FreeFuncType destoryFunc_=NULL):        //定义模板构造函数运用泛化的方式实现类似父类指针指向子类的功能 
13.             pt(pt_),                                              //确保T*可以被U*初始化 
14.             destoryFunc(destoryFunc_) 
15.             { 
16.                 pCount = new size_t(1); 
17.             } 
18.         share_ptr(const share_ptr&sp): 
19.             pt(sp.pt),destoryFunc(sp.destoryFunc) 
20.         { 
21.             pCount=sp.pCount; 
22.             (*pCount)++; 
23.         } 
24.         share_ptr& operator=(const share_ptr&sp) 
25.         { 
26.             release();
27.             pt = sp.pt; 
28.             destoryFunc = sp.destoryFunc; 
29.             pCount=sp.pCount; 
30.             (*pCount)++; 
31.             return *this; 
32.         } 
33.         ~share_ptr() 
34.         { 
35.             release(); 
36.         } 
37.         T& operator*()const 
38.         { 
39.             return *pt; 
40.         } 
41.         T* operator->()const 
42.         { 
43.             return pt; 
44.         } 
45.         T* get() const 
46.         { 
47.             return pt; 
48.         } 
49.     private: 
50.         T* pt; 
51.         FreeFuncType destoryFunc; 
52.         void release() 
53.         { 
54.             (*pCount)--; 
55.             { 
56.             if(*pCount == 0 ) 
57.                 if(destoryFunc) 
58.                 { 
59.                     destoryFunc(pt); 
60.                 } 
61.                 else 
62.                 { 
63.                     delete pt; 
64.                 } 
65.             } 
66.         } 
67.     }; 
68. } 
69. #endif // SHARE_PTR_H_INCLUDED 

这样使用起来就容易多了，但是还是需要有第二个模板参数。有没有可能省略第二个模板参数呢？路还很漫长啊～～