我的C++实践（10-15）

我的C++实践(10)：智能指针

转自 http://blog.csdn.net/zhoudaxia/article/details/4531761

    1、独占型智能指针： HolderPtr<T>。智能指针对象独占被管理对象的所有权，不允许对智能指针进行拷贝和赋值。可以提供一个release()函数来让出所有权。

[cpp]  view plain copy

1. //holderptr.hpp：独占型智能指针，不允许复制和赋值的智能指针  
2. #ifndef HOLDERPTR_HPP  
3. #define HOLDERPTR_HPP  
4. template<typename T>  
5. class HolderPtr{  
6. private:  
7.     T* ptr; //指向它所持有的对象（前提是该对象存在）  
8. public:  
9.     HolderPtr():ptr(0){ //缺省构造函数：指向空对象  
10.     }  
11.     explicit HolderPtr(T* p):ptr(p){ //针对内建指针的构造函数，禁止隐式转型  
12.     }  
13.     ~HolderPtr(){  
14.         if(ptr)  
15.             delete ptr;  
16.     }  
17.     HolderPtr<T>& operator=(T* p){ //针对内建指针的赋值运算符  
18.         if(ptr) delete ptr; //删除原来持有的对象  
19.         ptr=p;  
20.         return *this;  
21.     }  
22.     T& operator*(){ //指针运算符  
23.         return *ptr;  
24.     }  
25.     T& operator*() const{ //const版本  
26.         return *ptr;  
27.     }  
28.     T* operator->(){ //箭头运算符  
29.         return ptr;  
30.     }  
31.     T* operator->() const{ //const版本  
32.         return ptr;  //在返回类型中，T本身可以是const类型，故用T*而不用T const*  
33.     }  
34.     T* get() const{ //获取里面的内建指针  
35.         return ptr;  
36.     }  
37.     T* release(){ //释放对持有对象的所有权  
38.         T* ret=ptr;  
39.         ptr=0; //这样本holder不再持有对象，即使析构也无影响（ptr变成NULL）  
40.         return ret; //返回新的持有对象的指针  
41.     }  
42.     void exchange_with(HolderPtr<T>& h){ //与另一个holder交换对象所有权  
43.         swap(ptr,h.ptr);  
44.     }  
45.     void exchange_with(T*& p){ //与其他的内建指针交换对象所有权  
46.         swap(ptr,p);  
47.     }  
48.     void reset(T* p=0){ //重置为一个新的指针  
49.         if(ptr!=p){  
50.             delete ptr;  
51.             ptr=p;  
52.         }  
53.     }  
54. private:  
55.     //禁止对智能指针的拷贝和赋值  
56.     HolderPtr(HolderPtr<T> const&);  
57.     HolderPtr<T>& operator=(HolderPtr<T> const&);  
58.     void swap(T*& lhs,T*& rhs){ //指针交换函数  
59.         T* tmp=lhs;  
60.         lhs=rhs;  
61.         rhs=tmp;  
62.     }  
63. };  
64. #endif  

   

    2、转移型智能指针： AutoPtr<T>。允许对智能指针进行拷贝或赋值，但拷贝或赋值后对象所有权就会自动转移到其他的智能指针，原来的智能指针指向NULL。例如标准库中的std::auto_ptr就属于这一类智能指针。

[cpp]  view plain copy

1. //autoptr.hpp：转移型智能指针  
2. #ifndef AUTOPTR_HPP  
3. #define AUTOPTR_HPP  
4. template<typename T>  
5. class AutoPtr{  
6. private:  
7.     T *pointee; //指向持有的对象  
8.     template<typename U>  
9.     friend class AutoPtr;  
10. public:  
11.     explicit AutoPtr(T* p=0):pointee(p){  
12.     }  
13.     AutoPtr(AutoPtr<T>& rhs):pointee(rhs.release()){ //默认的拷贝构造函数  
14.         //参数不能为const的，因为转移对象的所有权需要修改指针成员的值  
15.     }  
16.     //针对其他兼容类型的拷贝构造函数  
17.     template<typename U>  
18.     AutoPtr(AutoPtr<U>& rhs):pointee(rhs.release()){  
19.     }  
20.     AutoPtr<T>& operator=(AutoPtr<T>& rhs){ //默认的赋值运算符  
21.         if(this!=&rhs) reset(rhs.release()); //转移对象的所有权  
22.         return *this;  
23.     }  
24.     //针对其他兼容类型的赋值  
25.     template<typename U>  
26.     AutoPtr<T>& operator=(AutoPtr<U>& rhs){  
27.         if(this->pointee!=rhs.pointee) reset(rhs.release());  
28.         return *this;  
29.     }  
30.       
31.     AutoPtr<T>& operator=(T* p){ //针对内建指针的赋值运算符  
32.         if(pointee) delete pointee; //删除原来持有的对象  
33.         pointee=p;  
34.         return *this;  
35.     }  
36.       
37.     ~AutoPtr(){  
38.         if(pointee) delete pointee;  
39.     }  
40.     T& operator*() const{ //重载解引用运算符  
41.         return *pointee;  
42.     }  
43.     T& operator*(){ //非const版本  
44.         return *pointee;  
45.     }  
46.     T* operator->() const{ //重载箭头操作符  
47.         return pointee;  
48.     }  
49.     T* operator->(){ //非const版本  
50.         return pointee;  
51.     }  
52.       
53.     T* get() const{  
54.         return pointee;  
55.     }  
56.     T* release(){ //释放对象的所有权  
57.         T* old=pointee;  
58.         pointee=0;  
59.         return old;  
60.     }  
61.     void reset(T* p=0){ //重置为一个新指针  
62.         if(pointee!=p){  
63.             delete pointee;  
64.             pointee=p;  
65.         }  
66.     }  
67. };  
68. #endif  

    注意在拷贝和赋值时，函数的参数不能加const修饰符，因为转移对象的所有权需要修改参数的指针成员的值。另外要注意针对其他兼容类型的拷贝构造函数和赋值操作符使用了成员函数模板，它并不会覆盖默认的拷贝构造函数和赋值运算，因此我们还要显示提供默认的拷贝构造函数和赋值操作符，因为它们都是深拷贝和深赋值。
    3、共享型智能指针： CountingPtr<T,CP,OP>。多个智能指针可以指向一个对象。这要对共享的指针个数进行计数，当计数器变为0时，就释放指向的对象。有多种计数策略（比如侵入式和非侵入式）和对象释放策略（比如对普通对象和数组对象释放策略不一样，有时可能必须要用free()来释放内存等），因此通常可以把计数功能和对象释放功能抽离出来设计成独立的计数policy和对象释放policy，通过模板参数传递给智能指针。我们这里把policy设计成具有成员函数模板的普通类，而不是模板，这样传递policy时就不需要模板模板参数，用普通的类型参数就可以了。
    非侵入式计数器：计数器并不存储在所指向的对象内部，而是用独立的空间来存储和管理计数器。由于计数器对象比较小，又要被多个共享型智能指针所共享，为了提高性能，通常设计一个独立的分配器来分配大小固定的计数器对象。计数器policy类的操作包括分配、释放、加1、减1、判0等，设计成成员函数模板，形参为模板参数的指针类型，表示要计数的指针。代码如下：

[cpp]  view plain copy

1. //simpleallocator.hpp：简单的计数器内存分配器，这里只分配和管理size_t大小的内存空间  
2. #ifndef SIMPLE_ALLOCATOR_HPP  
3. #define SIMPLE_ALLOCATOR_HPP  
4. #include <cstddef>  
5. size_t* alloc_counter(){ //分配size_t大小的内存  
6.     return ::new size_t;  
7. }  
8. void dealloc_counter(size_t* ptr){ //释放内存  
9.     ::delete ptr;  
10. }  
11. #endif  

[cpp]  view plain copy

1. //simplerefcount.hpp：简单的非侵入式计数器  
2. #ifndef SIMPLE_REFCOUNT_HPP  
3. #define SIMPLE_REFCOUNT_HPP  
4. #include <cstddef>  //用到size_t的定义  
5. #include "simpleallocator.hpp"  
6. class SimpleReferenceCount {  
7. private:  
8.     size_t* counter; // 分配的计数器  
9. public:  
10.     SimpleReferenceCount () {  
11.         counter = NULL;  
12.     }  
13.     // 缺省的拷贝构造函数和赋值运算符都是允许的，  
14.     // 因为它们只是拷贝这个共享计数器  
15.       
16.     template<typename T> void init (T*) { //分配计数器，并初始化为1  
17.         counter = alloc_counter();        //形参T*表示要计数的指针  
18.         *counter = 1;  
19.     }  
20.     template<typename T> void dispose (T*) { //释放计数器  
21.         dealloc_counter(counter);  
22.     }  
23.     template<typename T> void increment (T*) { //计数值加1  
24.         ++*counter;  
25.     }  
26.     template<typename T> void decrement (T*) { //计数值减1  
27.         --*counter;  
28.     }  
29.     template<typename T> bool is_zero (T*) { //检查计数值是否为0  
30.         return *counter == 0;  
31.     }  
32. };  
33. #endif  

    侵入式计数器：将计数器放到被管理对象本身的类型中，是这个类型的一个普通成员变量，因此无需独立的分配器。侵入式计数器一般专用于管理某一种具体类型。计数器类应设计成模板，用一个模板参数来传递用作为计数器的成员变量指针。代码如下：

[cpp]  view plain copy

1. //memberrefcount.hpp：侵入式计数器  
2. #ifndef MEMBER_REFCOUNT_HPP  
3. #define MEMBER_REFCOUNT_HPP  
4. template<typename ObjectT,        // 计数器所在对象（即被智能指针管理的对象）的类型  
5.          typename CountT,         // 计数器的类型  
6.          CountT ObjectT::* CountP> // 计数器所在位置（目标类型的成员指针）  
7. class MemberReferenceCount{  
8. public:  
9.     // 缺省构造函数和析构函数都是允许的  
10.     void init (ObjectT* object) { //对象的计数器的值初始化为1  
11.         object->*CountP = 1;  
12.     }  
13.     void dispose (ObjectT*) { //释放计数器，ObjectT*是要计数的对象指针  
14.         //并不需要执行任何操作  
15.         //因为计数器是目标类型的一个普通成员变量  
16.         //会随着目标对象的析构而自动释放  
17.     }  
18.     void increment (ObjectT* object) { //计数值加1  
19.         ++(object->*CountP); //->*的优先级低于++  
20.     }  
21.     void decrement (ObjectT* object) { //计数值减1  
22.         --(object->*CountP);  
23.     }  
24.     bool is_zero (ObjectT* object) { //检查计数值是否为0  
25.         return object->*CountP == 0;  
26.     }  
27. };  
28. #endif  

    对象释放器：对普通对象用delete，对数组对象用delete[]，有时我们可能必须要使用其他的方式来释放对象，比如用C函数free()。我们把它们设计不同的policy类。如下：

[cpp]  view plain copy

1. //objpolicies.hpp：对象释放器，根据对象的不同的类型，有不同的释放策略  
2. #ifndef OBJPOLICIES_HPP  
3. #define OBJPOLICIES_HPP  
4. class StandardObjectPolicy{ //普通型对象的释放  
5. public:  
6.     template<typename T> void dispose (T* object){  
7.         delete object;  
8.     }  
9. };  
10. class StandardArrayPolicy { //数组对象的释放  
11. public:  
12.     template<typename T> void dispose (T* array){  
13.         delete[] array;  
14.     }  
15. };  
16. //其他对象释放策略，比如直接用free()等  
17. //...  
18. #endif  

    使用了计数policy和对象释放policy的共享型智能指针实现如下：

[cpp]  view plain copy

1. //countingptr.hpp：共享型智能指针，当对象的引用计数器变为0时，就删除指向的对象  
2. #ifndef COUNTINGPTR_HPP  
3. #define COUNTINGPTR_HPP  
4. #include "simplerefcount.hpp"  
5. #include "objpolicies.hpp"  
6. template<typename T,  
7.          typename CounterPolicy = SimpleReferenceCount,  
8.          typename ObjectPolicy = StandardObjectPolicy>  
9. class CountingPtr : private CounterPolicy, private ObjectPolicy { //模板参数作为基类  
10. private:   
11.     typedef CounterPolicy CP;  //定义简单的别名：计数器的类型  
12.     typedef ObjectPolicy  OP;  //对象释放器的类型  
13.       
14.     T* object_pointed_to;      //所引用的对象（如果没有则为NULL）  
15.       
16.     template<typename T2,typename CP2,typename OP2>  
17.     friend class CountingPtr; //用于从兼容类型进行拷贝，要访问兼容类型的私有成员    
18.     /* 
19.     class BoolSupport{ //私有嵌套类，用于支持智能指针转型为成员指针，                                 
20.                        //从而可直接隐式转型为bool类型 
21.         int dummy; 
22.     }; 
23.     */  
24.     void init (T* p) { // 用普通指针进行初始化  
25.         if (p != NULL) {  
26.             CounterPolicy::init(p);  
27.         }  
28.         this->object_pointed_to = p;  
29.     }  
30.       
31.      //拷贝用的成员函数模板：拷贝指针并且增加被拷贝指针的计数值  
32.     template<typename S>  
33.     void attach (CountingPtr<S,CP,OP> const& cp) {  
34.         //拷贝内建的指针  
35.         this->object_pointed_to = cp.object_pointed_to;  
36.         if (cp.object_pointed_to != NULL) {  
37.             //增加被拷贝的智能指针的引用计数  
38.             CP::increment(cp.object_pointed_to);  
39.         }  
40.     }  
41.       
42.     void detach() { // 减少本类指针引用计数值，如果变成0，则释放该计数器和管理的对象  
43.         if (this->object_pointed_to != NULL) { //必须要检查是否为空  
44.             //减少本类的指针引用计数  
45.             CounterPolicy::decrement(this->object_pointed_to);  
46.             if (CounterPolicy::is_zero(this->object_pointed_to)) {  
47.                 CounterPolicy::dispose(this->object_pointed_to); //使用计数器来释放计数器  
48.                 ObjectPolicy::dispose(this->object_pointed_to);  //使用对象释放器来释放对象  
49.             }  
50.         }  
51.     }  
52.       
53. public:  
54.     CountingPtr() { //缺省构造函数  
55.         this->object_pointed_to = NULL;  
56.     }  
57.       
58.     explicit CountingPtr(T* p) { //针对内建指针的构造函数  
59.         this->init(p); //使用普通指针初始化  
60.     }  
61.       
62.     template<typename U>  
63.     explicit CountingPtr(U* p){ //针对派生类指针的构造函数模板  
64.         this->init(p); //使用派生类指针初始化  
65.     }  
66.       
67.     CountingPtr(CountingPtr<T,CP,OP> const& cp) //缺省拷贝构造函数  
68.      : CP((CP const&)cp),      //拷贝基类部分的计数策略和对象释放策略  
69.        OP((OP const&)cp) {  
70.         this->attach(cp);  //复制指针并增加被拷贝的智能指针计数值  
71.     }  
72.       
73.     //对兼容类型的拷贝构造函数模板，支持了隐式转型，  
74.     //当T是void类型，或者是S的基类时，可从兼容类型转型为本类型  
75.     template<typename S>  
76.     CountingPtr(CountingPtr<S,CP,OP> const& cp)  
77.         :CP((CP const&)cp),  
78.          OP((OP const&)cp),  
79.          object_pointed_to(cp.object_pointed_to){  
80.          if(cp.object_pointed_to!=NULL)  
81.             //增加被拷贝的智能指针计数值  
82.             CP::increment(cp.object_pointed_to);  
83.     }      
84.   
85.     CountingPtr<T,CP,OP>&  
86.     operator= (CountingPtr<T,CP,OP> const& cp) { //缺省的赋值运算符  
87.         if (this->object_pointed_to != cp.object_pointed_to) {  
88.             this->detach();  //减少本类指针引用计数值，如果变成0，则释放该计数器和管理的对象  
89.             CP::operator=((CP const&)cp);  //对基类部分中的计数策略和对象释放策略进行赋值  
90.             OP::operator=((OP const&)cp);  
91.             this->attach(cp);  //拷贝指针并且增加被赋值的智能指针计数值  
92.         }  
93.         return *this;  
94.     }  
95.       
96.     template<typename S>  
97.     CountingPtr<T,CP,OP>&  
98.     operator= (CountingPtr<S,CP,OP> const& cp) { //对兼容类型的赋值运算符模板  
99.         if (this->object_pointed_to != cp.object_pointed_to) {  
100.             this->detach();  //减少本类指针引用计数值，如果变成0，则释放该计数器和管理的对象  
101.             CP::operator=((CP const&)cp);  //对基类部分中的计数策略和对象释放策略进行赋值  
102.             OP::operator=((OP const&)cp);  
103.             this->attach(cp);  //拷贝指针并且增加被赋值的智能指针的引用计数值  
104.         }  
105.         return *this;  
106.     }  
107.       
108.     CountingPtr<T,CP,OP>& operator=(T* p) { //针对内建指针的赋值运算符  
109.         if(p != this->object_pointed_to){ //计数指针不能指向*p  
110.             this->detach();  //减少本类指针引用计数值，如果变成0，则释放该计数器和管理的对象  
111.             this->init(p);   //用一个普通指针进行初始化            
112.         }  
113.         return *this;  
114.     }  
115.       
116.     template<typename U>  
117.     CountingPtr<T,CP,OP>& operator=(U* p){ //针对派生类指针的赋值运算符模板  
118.         if(p != this->object_pointed_to){ //计数指针不能指向*p  
119.             this->detach();  //减少本类指针引用计数值，如果变成0，则释放该计数器和管理的对象  
120.             this->init(p);   //用一个派生类指针进行初始化  
121.         }  
122.         return *this;  
123.     }  
124.       
125.     ~CountingPtr() { //析构函数  
126.         this->detach();  //减少本类指针引用计数值，如果变成0，则释放该计数器和管理的对象  
127.     }  
128.       
129.     T* operator->(){ //重载箭头运算符  
130.         return this->object_pointed_to;  
131.     }  
132.           
133.     T* operator->() const { //const版本  
134.         return this->object_pointed_to;  
135.     }  
136.   
137.     T& operator*(){ //重载解引用运算符  
138.         return *this->object_pointed_to;  
139.     }  
140.       
141.     T& operator*() const { //const版本  
142.         return *this->object_pointed_to;  
143.     }  
144.     /* 
145.     //到成员指针的转型，从而可以直接隐式转型为bool类型 
146.     operator BoolSupport::*() const{ 
147.         return this->object_pointed_to ? (&BoolSupport::dummy) : (BoolSupport::*)0; 
148.     } 
149.     */  
150.     operator bool() const{ //直接的bool转型，会有一些副作用（比如导致两个智能指针可以相加）  
151.         return this->object_pointed_to!=(T*)0;  
152.     }  
153.     //比较运算符：与内建指针的直接比较  
154.     friend bool operator==(CountingPtr<T,CP,OP> const& cp,T const* p){  
155.         return cp==p;  
156.     }  
157.       
158.     friend bool operator==(T const* p,CountingPtr<T,CP,OP> const& cp){  
159.         return p==cp;  
160.     }  
161.       
162.     //其他的一些比较运算符  
163.     //...  
164. };  
165. //两个智能指针之间的比较：用内联函数  
166. template<typename T1,typename T2,  
167.          typename CP,typename OP>  
168. inline bool operator==(CountingPtr<T1,CP,OP> const& cp1,  
169.                         CountingPtr<T2,CP,OP> const& cp2){  
170.     return cp1.operator->()==cp2.operator->();  
171. }  
172. #endif  

 

    有几点要注意：
    （1）在detach()中，在减少计数值之前必须要检查智能指针是否为空，因为空指针并没有可关联的计数器。
    （2）CountingPtr<T,CP,OP>直接继承了两种policy类，这样当policy类为空类时，就可以执行空基类优化。比如前面的侵入式计数器MemberReferenceCount就是一个空类，在CountingPtr中使用它时可以被优化掉，但非侵入式计数器SimpleReferenceCount不是空类（有一个指针成员），不能被优化。而对象释放器均为空类。可见一般非侵入式计数器会增加智能指针的大小（当然我们可以使用压缩存储技术来优化，这需要改变该policy类的设计），侵入式计数器则会增加被管理的对象的大小。
    （3）计数器类中，函数模板的形参表示要进行计数的指针，但函数内部却并不需要用到这个指针，因为它只需要改变计数值即可。
    （4）智能指针的常数性：与内建指针相比，X const*(即const X*)与CountingPtr<X const>对应，表示所指对象为常数。X* const与CountingPtr<X> const对应，表示指针本身为常数。因此在->和*重载中，const版本的返回类型是T*或T&，而不是T const*或T const&，因为T本身可以是const类型。
    （5）智能指针的转型：内建指针可以隐式转型为基类指针、void*类型或bool类型。对智能指针，我们可以添加转型成员函数，以允许CountingPtr<T>转型为bool类型。我们也可以转型为CountingPtr<B>（通过单参数的拷贝构造函数完成），其中B为void类型或者为T的基类，使用这种转型时就不能用侵入式计数器，因为void类型没有计数器，且基类的计数器与子类的计数器通常也不同（各有各的计数器）。注意我们并不允许智能指针直接转型为内建指针，因为我们设计智能指针就是为了避免使用内建指针，而且如果允许的话，对智能指针进行运算（如cp[n],cp2-cp1），将很难确定其结果。对于bool转型，可直接提供operator bool()运算符，但这会有一定的副作用，比如导致两个智能指针可以相加了。我们可以换一种解决方案，提供一个到成员指针的转型运算符（这需要增加一个私有的嵌套类，注意嵌套类并不会增加智能指针CountingPtr的大小），当转型到成员指针后，可以自动地隐式转型为bool类型。注意成员指针与内建指针不同，并不能对成员指针进行算术运算，因此没有副作用。但是，我在gcc上测试出这种方案不能通过（代码中的这部分我注释掉了），有可能是因为gcc并不支持到成员指针的转型运算符。
    （6）智能指针的比较：内建指针支持相等比较(==,!=)和排序比较(,<,<=等）。对智能指针，可以添加相应的比较运算符函数。要注意有智能指针和内建指针的直接比较，也有两个智能指针之间的比较。对于两个智能指针之间的比较，我们把它设计成了一个独立的全局函数模板（在类外面），允许兼容类型的智能指针进行比较。由于是全局的非成员函数，因此要显式加inline表示内联，以提高性能。
    4、测试代码。 当智能指针使用侵入式计数器时，由于计数器是在目标类型对象的内部，用于专门对这个类型的对象进行计数。因此为了使用方便，我们通常把智能指针组合到目标类型中，成为它的一个类型成员（这并没有增加目标类型的大小），这样通过这个类型成员就可以方便的定义我们需要的智能指针。

[cpp]  view plain copy

1. //smartptrtest.cpp：对各种智能指针的测试  
2. #include "holderptr.hpp"  
3. #include "autoptr.hpp"  
4. #include "countingptr.hpp"  
5. #include "memberrefcount.hpp"  
6. #include <iostream>  
7. class Something{ //测试类  
8. public:  
9.     void perform() const{  
10.     }  
11. };  
12. class Derived: public Something{ //测试类  
13. };  
14. class MyClass{ //使用侵入式计数器的测试类  
15. public:  
16.     size_t ref_count; //计数器  
17. public:  
18.     typedef CountingPtr<MyClass,  
19.                         MemberReferenceCount<MyClass,size_t,&MyClass::ref_count> >  
20.             SmartPtr; //管理本对象的智能指针类型  
21.               
22.     void perform() const{  
23.     }  
24.     size_t getCounter(){  
25.         return ref_count;  
26.     }  
27.     //...  
28. };  
29. void read_something(Something* x){ //测试函数  
30. }  
31. Something* load_something(){ //测试独占型指针的获取和转移  
32.     HolderPtr<Something> result(new Something);  
33.     read_something(result.get());  
34.     Something* ret=result.get();  
35.     result.release();  
36.     return ret;  
37. }  
38. void do_test_things(){ //测试各个智能指针  
39.     HolderPtr<Something> first(new Something);  
40.     first->perform(); //测试箭头操作符  
41.     (*first).perform(); //测试解引用操作符  
42.   
43.     AutoPtr<Something> second(new Something);  
44.     second->perform();  
45.     (*second).perform();  
46.     AutoPtr<Something> tmp(second); //测试缺省的拷贝构造  
47.     AutoPtr<Derived> a1(new Derived);  
48.     AutoPtr<Something> b1(a1); //测试兼容类型的拷贝构造  
49.     second=a1; //测试兼容类型的赋值  
50.       
51.     CountingPtr<Something> third(new Something);  
52.     third->perform();  
53.     (*third).perform();  
54.     CountingPtr<Something> fouth(third);  
55.     CountingPtr<Derived> a2(new Derived);  
56.     CountingPtr<Something> b2(a2); //测试兼容类型的拷贝构造  
57.     third=a2; //测试兼容类型的赋值  
58.     third=new Something; //测试内建指针的赋值  
59.     CountingPtr<Something> comp1(new Derived); //测试针对派生类指针的构造函数  
60.     CountingPtr<Something> comp2;  
61.     comp2=new Derived; //测试针对派生类指针的赋值运算符  
62.       
63.     if(a2) //测试bool转型  
64.         std::cout<<"a2 is not empty."<<std::endl;  
65.     if(a2==b2) //测试两个智能指针的内容是否相等  
66.         std::cout<<"a2 is equal to b2."<<std::endl;  
67.           
68.     CountingPtr<MyClass,  
69.         MemberReferenceCount<MyClass,size_t,&MyClass::ref_count> >   
70.         a3(new MyClass); //测试侵入式的智能指针  
71.     a3->perform();  
72.     MyClass::SmartPtr b3(a3);  
73.     std::cout<<b3->getCounter()<<std::endl;  
74. }  
75. int main(){  
76.     HolderPtr<Something> ptr(load_something());  
77.     do_test_things();  
78.     return 0;  
79. }  

 

    从代码中可以看出，类型MyClass使用了侵入式计数器，因此我把管理这个类型的智能指针CountingPtr组合进来，定义成一个简洁的名字。在下面的测试代码中我们就可以看出，使用MyClass::SmartPtr要比使用CountingPtr<MyClass,MemberReferenceCount<MyClass,size_t,&MyClass::ref_count> >简洁得多。

============================================================================================

我的C++实践(11)：存放异类对象的元组类型

转自 http://blog.csdn.net/zhoudaxia/article/details/4538589

    C++中的数组类型和容器类型都是存放同类型对象的，有一个标准库类型std::pair可以存放两个异类对象。借助模板，我们可以开发出存放异类对象的类型。
    1、二元组类型： Duo<T1,T2>。存放两个异类对象的元组类型，类似于std::pair。设置和获取各个域的操作直接为Duo<T1,T2>的成员函数。make_duo函数用来方便地创建二元组对象，类似于make_pair。

[cpp]  view plain copy

1. //duo.hpp：存放两个异类对象的二元组类型  
2. #ifndef DUO_HPP  
3. #define DUO_HPP  
4.   
5. template <typename T1, typename T2>  
6. class Duo {  
7. public:  
8.     typedef T1 Type1; // 用于访问第1个域的类型  
9.     typedef T2 Type2; // 用于访问第2个域的类型  
10.     enum { N = 2 };   // 域的个数  
11. private:  
12.     T1 value1; // 第1个域的值  
13.     T2 value2; // 第2个域的值  
14. public:   
15.     Duo() : value1(), value2() { //缺省构造函数  
16.     }  
17.     Duo (T1 const& a, T2 const& b)  
18.      : value1(a), value2(b) {  
19.     }  
20.   
21.     // 针对兼容类型的拷贝构造函数，可进行隐式类型转换  
22.     template <typename U1, typename U2>  
23.     Duo (Duo<U1,U2> const& d)  
24.      : value1(d.v1()), value2(d.v2()) {  
25.     }  
26.   
27.     // 针对兼容类型的赋值运算符，可进行隐式类型转换  
28.     template <typename U1, typename U2>  
29.     Duo<T1, T2>& operator = (Duo<U1,U2> const & d) {  
30.         value1 = d.value1;  
31.         value2 = d.value2;  
32.         return *this;  
33.     }  
34.   
35.     // 访问域的函数  
36.     T1& v1() { //因为返回非const引用，可以修改对象的value1成员，因此函数  
37.                //也必须是非const的  
38.         return value1;  
39.     }  
40.     T1 const& v1() const { //const版本  
41.         return value1;  
42.     }      
43.     T2& v2() {   
44.         return value2;  
45.     }  
46.     T2 const& v2() const {  
47.         return value2;  
48.     }  
49. };  
50.   
51. // 两个二元组的比较运算符（允许混合类型）  
52. template <typename T1, typename T2,  
53.           typename U1, typename U2>  
54. inline  
55. bool operator==(Duo<T1,T2> const& d1, Duo<U1,U2> const& d2){  
56.     return d1.v1()==d2.v1() && d1.v2()==d2.v2(); //相等比较  
57. }  
58.   
59. template <typename T1, typename T2,  
60.           typename U1, typename U2>  
61. inline  
62. bool operator!=(Duo<T1,T2> const& d1, Duo<U1,U2> const& d2){  
63.     return !(d1==d2);  //不等比较，可利用上面的相等比较运算符  
64. }  
65.   
66. // 包装函数：用来创建和初始化二元组的函数  
67. template <typename T1, typename T2>   
68. inline  
69. Duo<T1,T2> make_duo(T1 const & a, T2 const & b){  
70.     return Duo<T1,T2>(a,b);  
71. }  
72.   
73. #endif  

[cpp]  view plain copy

1. //duotest.cpp：对duo的测试  
2. #include "duo.hpp"  
3. #include <iostream>  
4.   
5. Duo<float,int> foo (){  
6.     return make_duo(42,42);  
7. }  
8.   
9. int main(){  
10.     if (foo() == make_duo(42,42.0)) {  
11.         std::cout<<"foo()==make_duo(42,42.0)"<<std::endl;  
12.     }  
13.     return 0;  
14. }  

    有几点要注意：
    （1）我们用typedef定义了所存放的两个类型，这样就可以方便地访问两个类型。
    （2）我们提供了针对兼容类型的拷贝构造函数和赋值运算符，从而可进行隐式类型转换。
    （3）访问域的函数有非const版本和const版本。若函数返回非const引用，可以修改对象的value1成员，因此函数也必须是非const的，以表示它可以修改对象的值。
    （4）比较运算符允许对混合类型进行比较。make_duo是包装函数，用来方便地创建和初始化二元组。
    2、一般的元组类型： 可递归Duo<A, Duo<B,C> >类型表示一般的元组类，它使用模板元编程技术通过对Duo进行模板递归来实现。DuoT<N,T>用来获取元组类T中第N个域的类型，DuoValue<N,T>用来设置或获取元组类T中第N个域的值，它们也都使用了模板元编程技术来实现，用了很多模板特化来结束递归。val<N>(d)用来方便地设置和获取元组d的第N个域的值。

[cpp]  view plain copy

1. //recduo.hpp：一般多元组类型，用模板元编程技术来实现（对Duo进行模板递归）  
2. #ifndef REC_DUO_HPP  
3. #define REC_DUO_HPP  
4. #include "duo.hpp"     //普通的Duo二元组模板  
5. #include "typeop.hpp"  //用TypeOp来确保返回需要的类型  
6. /*  
7.  * Duo<A, Duo<B,C> >：用可递归Duo实现一般的多元组类型 
8.  */  
9. template <typename A, typename B, typename C>  
10. class Duo<A, Duo<B,C> > { //对普通Duo的局部特化，用来递归地表示一般的多元组  
11. public:  
12.     typedef A Type1;         // 第1个域的类型  
13.     typedef Duo<B,C> Type2;  // 可递归Duo类型：包含了其他各个域  
14.     enum { N = Duo<B,C>::N + 1 };  // 域的个数  
15. private:  
16.     Type1 value1; // 第1个域的值  
17.     Type2 value2; // 可递归Duo对象：包含了其他的域  
18. public:   
19.     Duo() : value1(), value2() { //缺省构造函数  
20.     }  
21.     Duo (Type1 const& a, Type2 const& b)  
22.      : value1(a), value2(b){  
23.     }  
24.   
25.     // 针对兼容类型的拷贝构造函数，可进行隐式类型转换  
26.     template <typename U1, typename U2>  
27.     Duo(Duo<U1,U2> const& d)  
28.      : value1(d.v1()), value2(d.v2()) {  
29.     }  
30.   
31.     // 针对兼容类型的赋值运算符，可进行隐式类型转换  
32.     template <typename U1, typename U2>  
33.     Duo<Type1, Type2>& operator=(Duo<U1,U2> const & d) {  
34.         value1 = d.value1;  
35.         value2 = d.value2;  
36.         return *this;  
37.     }  
38.       
39.     Type1& v1() { // 访问第1个域的函数  
40.         return value1;  
41.     }  
42.     Type1 const& v1() const { //const版本  
43.         return value1;  
44.     }  
45.       
46.   
47.     Type2& v2() { //访问可递归Duo对象  
48.         return value2;  
49.     }  
50.     Type2 const& v2() const {  
51.         return value2;  
52.     }  
53. };  
54. template <typename A>  
55. class Duo<A,void> { //终止递归的局部特化：Duo中只有一个域  
56. public:  
57.     typedef A    Type1;  // 第1个域的类型  
58.     typedef void Type2;  // 第2个域的类型，为void空类型  
59.     enum { N = 1 };  // 域的个数  
60. private:  
61.     Type1 value1;  // 第1个域的值  
62. public:  
63.       
64.     Duo() : value1() { //缺省构造函数  
65.     }  
66.     Duo (Type1 const & a)  
67.      : value1(a) {  
68.     }  
69.   
70.     // 访问域的函数  
71.     Type1& v1() {   
72.         return value1;  
73.     }  
74.     Type1 const& v1() const { //const版本  
75.         return value1;  
76.     }  
77.       
78.     void v2() { //因为只有一个域，故对第2个域不做任何事  
79.     }  
80.     void v2() const {  
81.     }  
82. };  
83.   
84. /* 
85.  * DuoT<N,T>：用来获取元组类T中第N个域的类型 
86.  * 元组类可以是普通的Duo（二元组），也可以是可递归Duo（一般的多元组） 
87.  */  
88. template <int N, typename T>  
89. class DuoT { //基本模板，获取第n个域的类型  
90. public:  
91.     typedef void ResultT; // 一般情况下返回void空类型  
92. };  
93.   
94. template <typename A, typename B>  
95. class DuoT<1, Duo<A,B> > { //特化：返回普通Duo第1个域的类型  
96. public:  
97.     typedef A ResultT;  
98. };  
99.   
100. template <typename A, typename B>  
101. class DuoT<2, Duo<A,B> > { //特化：返回普通Duo第2个域的类型  
102. public:  
103.     typedef B ResultT;  
104. };  
105.   
106. template <typename A, typename B, typename C>  
107. class DuoT<1, Duo<A, Duo<B,C> > > { //特化：返回可递归Duo第1个域的类型  
108. public:  
109.     typedef A ResultT;  
110. };  
111.   
112. template <typename A, typename B, typename C>  
113. class DuoT<2, Duo<A, Duo<B,C> > > { //特化：返回可递归Duo第2个域的类型  
114. public:  
115.     typedef B ResultT;  
116. };  
117.   
118. template <int N, typename A, typename B, typename C>  
119. class DuoT<N, Duo<A, Duo<B,C> > > { //特化：返回可递归Duo第N(N>=3)个域的类型  
120. public:  
121.     //它相当于第2个域（即Duo<B,C>）的第N-1个域的类型     
122.     typedef typename DuoT<N-1, Duo<B,C> >::ResultT ResultT;  
123. };  
124.   
125. /* 
126.  * DuoValue<N,T>：用来设置或者获取元组类T中第N个域的值 
127.  * 元组类可以是普通的Duo（二元组），也可以是可递归Duo（一般的多元组） 
128.  */  
129. template <int N, typename T>  
130. class DuoValue{ //基本模板  
131. public:  
132.     static void get(T&){ // 一般情况下并不返回值  
133.     }  
134.     static void get(T const&){ //static成员函数不能有const修饰符  
135.     }  
136. };  
137.   
138. template <typename A, typename B>  
139. class DuoValue<1, Duo<A, B> > { //特化：设置或获取普通Duo第1个域的值  
140. public:  
141.     static A& get(Duo<A, B>& d) { //返回非const引用，可获取域的值，也可设置域的值  
142.                                   //因此参数d也必须是变量型的（非const的）  
143.                                   //否则d加const会使d.v1()会返回const引用  
144.         return d.v1();  
145.     }  
146.     static A const& get(Duo<A, B> const& d){ //返回const引用，只获取域的值  
147.         return d.v1();  
148.     }  
149. };  
150.   
151. template <typename A, typename B>  
152. class DuoValue<2, Duo<A, B> > { //特化：获取普通Duo第2个域的值  
153. public:  
154.     static B& get(Duo<A, B>& d) {   
155.         return d.v2();   
156.     }  
157.     static B const& get(Duo<A, B> const& d){   
158.         return d.v2();  
159.     }  
160. };  
161.   
162. template <typename A, typename B, typename C>  
163. class DuoValue<1, Duo<A, Duo<B,C> > > { //特化：获取可递归Duo第1个域的值  
164. public:  
165.     static A& get(Duo<A, Duo<B,C> > &d) {   
166.         return d.v1();   
167.     }  
168.     static A const& get(Duo<A, Duo<B,C> > const &d) {   
169.         return d.v1();   
170.     }  
171. };  
172.   
173. template <typename A, typename B, typename C>  
174. class DuoValue<2, Duo<A, Duo<B,C> > > { //特化：获取可递归Duo第2个域的值  
175. public:  
176.     static B& get(Duo<A, Duo<B,C> > &d) {   
177.         return d.v2().v1();   
178.     }  
179.     static B const& get(Duo<A, Duo<B,C> > const &d) {  
180.         return d.v2().v1();  
181.     }  
182. };  
183. template <int N, typename A, typename B, typename C>  
184. class DuoValue<N, Duo<A, Duo<B,C> > > { //特化：获取可递归Duo第N(N>=3)个域的值  
185. public:  
186.     //用TypeOp确保返回类型是非const的引用类型：用到了DuoT模板  
187.     static typename TypeOp<typename DuoT<N-1, Duo<B,C>   
188.                         >::ResultT>::RefT  
189.     get(Duo<A, Duo<B,C> >& d) {  
190.         //它相当于获取第2个域（即Duo<B,C>）的第N-1个域的值  
191.         return DuoValue<N-1, Duo<B,C> >::get(d.v2());  
192.     }  
193.   
194.     //用TypeOp确保返回类型是const引用类型  
195.     static typename TypeOp<typename DuoT<N-1, Duo<B,C>  
196.                         >::ResultT>::RefConstT  
197.     get(Duo<A, Duo<B,C> > const &d) {  
198.         return DuoValue<N-1, Duo<B,C> >::get(d.v2());  
199.     }  
200. };  
201. //包装函数：用于方便地设置或获取元组类第N个域的值  
202. //模板参数N要显式给出，A和B可通过演绎获得  
203. template <int N, typename A, typename B>   
204. inline typename TypeOp<typename DuoT<N, Duo<A, B>   
205.                     >::ResultT>::RefT  
206. val(Duo<A, B>& d){ //设置或者获取变量型duo的第N个值  
207.     return DuoValue<N, Duo<A, B> >::get(d);  
208. }  
209.   
210. template <int N, typename A, typename B>   
211. inline typename TypeOp<typename DuoT<N, Duo<A, B>   
212.              >::ResultT>::RefConstT  
213. val(Duo<A, B> const& d){ //只能获取常量型duo的第N个值  
214.     return DuoValue<N, Duo<A, B> >::get(d);  
215. }  
216.   
217. #endif  

[cpp]  view plain copy

1. //recduotest.cpp：对用可递归Duo实现的一般多元组类进行测试  
2.   
3. #include "recduo.hpp"  
4. #include <iostream>  
5.   
6. int main()  
7. {  
8.     // 创建和使用一个简单的duo  
9.     Duo<bool,int> d;  
10.     std::cout << d.v1() << std::endl;  
11.     std::cout << val<1>(d) << std::endl;  
12.   
13.     // 创建和使用三元组  
14.     Duo<bool,Duo<int,float> > t;  
15.   
16.     val<1>(t) = true;  
17.     val<2>(t) = 42;  
18.     val<3>(t) = 0.2;  
19.   
20.     std::cout << val<1>(t) << std::endl;  
21.     std::cout << val<2>(t) << std::endl;  
22.     std::cout << val<3>(t) << std::endl;  
23.     return 0;  
24. }  

    要注意的地方：
    （1）非const版本的那个静态get(d)函数由于返回的是非const引用，通过这个引用可获取d中相应域的值，也可设置d中相应域的值，因此参数d也必须是非const的（即变量型的），否则如果d是const的，则不能为d中的域设置新值，另一方面它会使d.v1()会返回const引用，从而get(d)不能返回非const引用。d为const的那个get(d)函数返回const引用，只能用于获取相应域的值，但函数本身不能是const的，因为static成员函数不能同时又是const的。
    （2）在特化版本DuoValue<N, Duo<A, Duo<B,C> > >中，我们用到了类型萃取技术中开发的TypeOp模板，这可确保返回类型是相应域类型的非const引用或const引用。
    （3）val<N>(d)要提供两个版本，一个接受非const的引用参数d，可设置和获取d的第N个域的值，一个接受const引用参数d，只能获取d的第N个域的值，注意基于“引用型参数是否是const的”可以构成重载关系。
    （4）元组类型Duo<A, Duo<B,C> >虽然理论上可以存放任意多个异类元素，但实际的编译器对模板嵌套深度是有限制的，因此这个元组类在实际应用时并不能存放太多个异类元素。
    3、元素个数有限的元组类： 由于模板嵌套深度在实际中有限制，因此有时我们更愿意开发一个接口简单的、元素个数有限的元组类。Tuple<P1,P2,P3,P4,P5>就是这样一个元组类，它可存放1-5个域。也是用模板递归来实现的，Tuple继承自前面的可递归Duo类型，其中该Duo类型的域个数有限。

[cpp]  view plain copy

1. //tuple.hpp：能存放1-5个元素的元组类型  
2. #ifndef TUPLE_HPP  
3. #define TUPLE_HPP  
4. #include "recduo.hpp"  //可递归Duo类型  
5. #include "typeop.hpp"  //用TypeOp来确保返回需要的类型  
6.   
7. class NullT { //代表无用类型  
8. };  
9.   
10. // 一般情况下，Tuple<>创建自“至少含有一个NullT的另一个Tuple<>“  
11. template <typename P1,  
12.           typename P2 = NullT,  
13.           typename P3 = NullT,  
14.           typename P4 = NullT,  
15.           typename P5 = NullT>  
16. class Tuple : public Duo<P1, typename Tuple<P2,P3,P4,P5,NullT>::BaseT> {  
17. public:  
18.     //基类是一个可递归Duo类型  
19.     typedef Duo<P1, typename Tuple<P2,P3,P4,P5,NullT>::BaseT>  
20.             BaseT;  
21.   
22.     Tuple() {} //缺省构造函数  
23.     Tuple(typename TypeOp<P1>::RefConstT a1,  
24.           typename TypeOp<P2>::RefConstT a2,  
25.           typename TypeOp<P3>::RefConstT a3 = NullT(),  
26.           typename TypeOp<P4>::RefConstT a4 = NullT(),  
27.           typename TypeOp<P5>::RefConstT a5 = NullT())  
28.      : BaseT(a1, Tuple<P2,P3,P4,P5,NullT>(a2,a3,a4,a5)) {  
29.     }  
30. };  
31.   
32. // 结束递归的局部特化：Tuple有2个域，它派生自普通的Duo  
33. template <typename P1, typename P2>  
34. class Tuple<P1,P2,NullT,NullT,NullT> : public Duo<P1,P2> {  
35. public:  
36.     typedef Duo<P1,P2> BaseT; //基类类型  
37.     Tuple() {}  
38.     Tuple(typename TypeOp<P1>::RefConstT a1,  
39.           typename TypeOp<P2>::RefConstT a2,  
40.           typename TypeOp<NullT>::RefConstT = NullT(),  
41.           typename TypeOp<NullT>::RefConstT = NullT(),  
42.           typename TypeOp<NullT>::RefConstT = NullT())  
43.      : BaseT(a1, a2) {  
44.     }  
45. };  
46.   
47. // 特化：Tuple只有1个域，它派生自只有一个域的Duo特化  
48. template <typename P1>  
49. class Tuple<P1,NullT,NullT,NullT,NullT> : public Duo<P1,void> {  
50.   public:  
51.     typedef Duo<P1,void> BaseT;  
52.     Tuple() {}  
53.     Tuple(typename TypeOp<P1>::RefConstT a1,  
54.           typename TypeOp<NullT>::RefConstT = NullT(),  
55.           typename TypeOp<NullT>::RefConstT = NullT(),  
56.           typename TypeOp<NullT>::RefConstT = NullT(),  
57.           typename TypeOp<NullT>::RefConstT = NullT())  
58.      : BaseT(a1) {  
59.     }  
60. };  
61.   
62. // 方便创建元组的make_tuple函数：1个实参的情况  
63. template <typename T1>  
64. inline  
65. Tuple<T1> make_tuple(T1 const& a1){  
66.     return Tuple<T1>(a1);  
67. }  
68.   
69. // 方便创建元组的make_tuple函数：2个实参的情况  
70. template <typename T1, typename T2>  
71. inline  
72. Tuple<T1,T2> make_tuple(T1 const& a1, T2 const& a2){  
73.     return Tuple<T1,T2>(a1,a2);  
74. }  
75.   
76. // // 方便创建元组的make_tuple函数：3个实参的情况  
77. template <typename T1, typename T2, typename T3>  
78. inline  
79. Tuple<T1,T2,T3> make_tuple(T1 const& a1, T2 const& a2,  
80.                            T3 const& a3){  
81.     return Tuple<T1,T2,T3>(a1,a2,a3);  
82. }  
83.   
84. // 方便创建元组的make_tuple函数：4个实参的情况  
85. template <typename T1, typename T2, typename T3, typename T4>  
86. inline  
87. Tuple<T1,T2,T3,T4> make_tuple(T1 const &a1, T2 const &a2,   
88.                               T3 const &a3, T4 const &a4){  
89.     return Tuple<T1,T2,T3,T4>(a1,a2,a3,a4);  
90. }  
91.   
92. // 方便创建元组的make_tuple函数：5个实参的情况  
93. template <typename T1, typename T2, typename T3,  
94.           typename T4, typename T5>  
95. inline  
96. Tuple<T1,T2,T3,T4,T5> make_tuple(T1 const &a1, T2 const &a2,  
97.                                  T3 const &a3, T4 const &a4,  
98.                                  T5 const &a5){  
99.     return Tuple<T1,T2,T3,T4,T5>(a1,a2,a3,a4,a5);  
100. }  
101. #endif  

[cpp]  view plain copy

1. //tupletest.cpp；对Tuple的测试  
2. #include "tuple.hpp"  
3. #include <iostream>  
4.   
5. int main()  
6. {  
7.     //创建和使用只有一个域的tuple  
8.     Tuple<int> t1;  
9.     val<1>(t1) += 42;  
10.     std::cout << t1.v1() << std::endl;  
11.   
12.     //创建和使用duo  
13.     Tuple<bool,int> t2;  
14.     std::cout << val<1>(t2) << ", ";  
15.     std::cout << t2.v1() << std::endl;  
16.   
17.     //创建和使用triple  
18.     Tuple<bool,int,double> t3;  
19.   
20.     val<1>(t3) = true; //设置各个域的值  
21.     val<2>(t3) = 42;  
22.     val<3>(t3) = 0.2;  
23.   
24.     std::cout << val<1>(t3) << ", ";  
25.     std::cout << val<2>(t3) << ", ";  
26.     std::cout << val<3>(t3) << std::endl;  
27.   
28.     t3 = make_tuple(false, 23, 13.13); //在创建时给定各个域的值  
29.   
30.     std::cout << val<1>(t3) << ", ";  
31.     std::cout << val<2>(t3) << ", ";  
32.     std::cout << val<3>(t3) << std::endl;  
33.   
34.     //创建和使用quadruple  
35.     Tuple<bool,int,float,double> t4(true,42,13,1.95583);  
36.     std::cout << val<4>(t4) << std::endl;  
37.     std::cout << t4.v2().v2().v2() << std::endl;  
38.     return 0;  
39. }  

    有几点要注意：
    （1）由于Tuple的域个数是可变的，因此我们声明了一个无用类型NullT来作模板参数的默认实参。这里并没有使用void类型，因为我们需要在构造函数中创建该类型的对象来作为函数形参的缺省值，而void类型不能创建对象。
    （2）用typedef定义BaseT来表示它继承的可递归Duo类型。
    （3）make_tuple用来方便地创建tuple元组。由于函数模板不能含有缺省模板实参，因此我们不能只写一个含有5个模板参数（通过给一些模板参数提供缺省实参）的make_tuple。如果想通过给函数的5个形参提供缺省调用实参来达到只编写一个make_tuple的愿望，这也不行，因为在演绎模板参数时，不会考虑缺省调用实参，这样就会导致使用缺省调用实参的模板参数演绎不出来，从而必须显式指定，使用起来不方便。总之，我们必须针对不同的域个数来定义相应的make_tuple。

=====================================================================

我的C++实践(12)：函数指针与仿函数

转自 http://blog.csdn.net/zhoudaxia/article/details/4545727

    C++的函数调用语法实体有函数、类似于函数的宏、函数指针、仿函数（即函数对象）。函数调用的方式有：
    （1）直接调用：通过函数名直接调用函数，函数起始地址成为指令的一部分，因此编译期就能确定调用了哪个函数。
    （2）间接调用：通过函数指针来调用函数，函数起始地址位于内存或寄存器的某处，因此到运行期才能确定调用哪个函数。
    （3）内联调用：直接在调用处展开函数代码，在编译期进行，因此到运行期就不存在函数调用了。
    对函数指针和仿函数的使用，基本上都是某种形式的回调。通常的程序库是库作者来编写库的代码，让用户来使用这些库，而回调正好相反，程序库调用了某个函数，而这个函数的代码需要由使用库的用户来编写。在实际应用中，仿函数与函数指针相比有很多优点，因为仿函数是类对象，因此我们可以在仿函数中关联状态信息（当然这会使仿函数类占内存空间，但我们可以使用空基类优化技术），这样根据不同的参数生成不同的函数实例。仿函数可以作为模板的类型实参来传递，也可以作为函数调用实参来传递。但仿函数是类对象，因此不能作为非类型模板实参，但函数指针可以作为非模板模板实参。通过仿函数，我们可以把所有的的普通函数都封装成仿函数类，这样就可以以对象的方式来统一使用各个函数。我们也可以对仿函数的各个参数类型和返回类型进行萃取，从而使其具有反射的能力，不同的仿函数还可以方便地组合起来使用。
    编写仿函数类的基本约定： 在仿函数类中要定义仿函数的参数个数常量NumParams、每个参数的类型typedef Param1T,typedef Param2T,...、返回类型tyepdef ReturnT。根据约定，我们的仿函数类应该编写成类似于下面的形式：

[cpp]  view plain copy

1. class PersonSort{  
2. public:  
3.     enum(NumParams=2 };  
4.     typedef bool ReturnT;  
5.     typedef Person const& Param1T;  
6.     typedef Person const& Param2T;  
7.     bool operator()(Person const& p1,Person const& p2) const{  
8.         //返回p1是否小于p2  
9.     }  
10. };  

    1、仿函数的类型萃取实现： FunctorParam<F,N>用来获取仿函数F的第N的参数的类型，当N值不大于实际的参数个数时，调用UsedFunctorParam<F,N>模板针对N的特化来获取相应位置处的参数类型，当N值大于实际的参数个数时，返回私有的无用嵌套成员类 NNest，它不能用来创建对象，因此没有副作用。代码如下：

[cpp]  view plain copy

1. //functorparam.hpp：获取仿函数各个参数的类型  
2. #ifndef FUNCTOR_PARAM_HPP  
3. #define FUNCTOR_PARAM_HPP  
4. #include "ifthenelse.hpp"  //用到了IfThenElse模板  
5. /* 
6.  * UsedFuctorParam<F,N>：抽取仿函数F的实际使用的第N个参数类型 
7.  */  
8. template <typename F, int N>  
9. class UsedFunctorParam; //基本模板  
10. //对每个N值，都提供一个局部特化，以获取相应位置处参数的类型  
11. //使用宏FunctorParamSpec(N)来编写UsedFunctorParam的特化，可以使代码更简洁  
12. #define FunctorParamSpec(N)                 /  
13. template<typename F>                        /  
14. class UsedFunctorParam<F, N>{               /  
15. public:                                     /  
16.     typedef typename F::Param##N##T Type;   /  
17. };  
18. //假设N到20为止，很少有多于20个参数的仿函数  
19. FunctorParamSpec(1)  
20. FunctorParamSpec(2)  
21. FunctorParamSpec(3)  
22. FunctorParamSpec(4)  
23. FunctorParamSpec(5)  
24. FunctorParamSpec(6)  
25. FunctorParamSpec(7)  
26. FunctorParamSpec(8)  
27. FunctorParamSpec(9)  
28. FunctorParamSpec(10)  
29. FunctorParamSpec(11)  
30. FunctorParamSpec(12)  
31. FunctorParamSpec(13)  
32. FunctorParamSpec(14)  
33. FunctorParamSpec(15)  
34. FunctorParamSpec(16)  
35. FunctorParamSpec(17)  
36. FunctorParamSpec(18)  
37. FunctorParamSpec(19)  
38. FunctorParamSpec(20)  
39. #undef FunctorParamSpec  //宏FunctorParamSpec的生命期结束  
40. /* 
41.  * FunctorParam<F,N>::Type：获取仿函数F的第N个参数的类型，当N大于实际参数 
42.  * 个数F::NumParams时，FunctorParam<F,N>::Type会返回私有的无用嵌套类 
43.  * NNest，它不能用来创建对象，因此没有副作用 
44.  */  
45. template <typename F, int N>  
46. class FunctorParam{  
47. private:  
48.     class Unused{ //嵌套类  
49.     private:  
50.         class NNest {}; //嵌套的无用成员类  
51.     public:  
52.         typedef NNest Type;  
53.     };  
54. public:  
55.     //获取相应位置处的参数类型  
56.     typedef typename IfThenElse<F::NumParams>=N,  
57.                                 UsedFunctorParam<F,N>,   
58.                                 Unused>::ResultT::Type  
59.             Type;  
60. };  
61. #endif  

    解释：
    （1）UsedFuctorParam<F,N>用来抽取仿函数F的实际使用的第N个参数类型，这里N没有超过仿函数的实际参数个数。参数类型的抽取是通过对每个N值提供一个局部特化来实现的。假设仿函数的参数个数最多为20，对具有工业强度的库而言，其设计一般要达到20个参数左右。实际中很少有多于20个参数的仿函数。这里#undef表示宏FunctorParamSpec的生命期结束，即下面就已经不存在FunctorParamSpec这个宏了，要用的话需要重新定义。
    （2）FunctorParam<F,N>中，N可以超过仿函数的实际参数个数，当超过时，就返回一个私有的无用嵌套类NNest，NNest在FunctorParam内部，在外部并不能直接用类名NNest来创建对象，因此对不存在的参数虽然返回了一个类型，但并没有产生副作用。这里用到了类型萃取技术中开发的IfThenElse模板。        
    2、把函数指针封装成仿函数： 直接对函数指针的返回类型和各个参数类型进行参数化，设计成仿函数类模板。
    下面的ForwardParamT<T>用于决定仿函数的参数类型T是传引用还是传原来的普通类型，T为类类型时则传引用，其他情况则传原来的普通类型（这需要用到类型萃取技术中开发的TypeOp模板），这样可以避免昂贵的拷贝构造函数调用。对仿函数参数为空（即为void）的情况，提供一个全局特化，指定空参数的类型为一个无副作用的哑类型。

[cpp]  view plain copy

1. //forwardparam.hpp：ForwardParamT<T>用于决定仿函数的参数类型T是传引用还是传原来的普通类型  
2. #ifndef FORWARD_PARAM_HPP  
3. #define FORWARD_PARAM_HPP  
4. #include "ifthenelse.hpp"  
5. #include "isclasst.hpp"  
6. #include "typeop.hpp"    //用于决定函数的参数是传引用还是传原来的类型  
7. template<typename T>  
8. class ForwardParamT{ //基本模板：T为类类型则传const引用，否则就传普通类型  
9. public:  
10.     typedef typename IfThenElse<IsClassT<T>::Yes,   
11.                                 typename TypeOp<T>::RefConstT,   
12.                                 typename TypeOp<T>::ArgT  
13.                                >::ResultT  
14.             Type;  
15. };  
16. template<>  
17. class ForwardParamT<void>{ //全局特化：void表示函数参数为空，则传哑类型Ununsed，  
18. private:                   //它不能创建对象，因此没有副作用  
19.     class Unused {};  
20. public:  
21.     typedef Unused Type;  
22. };  
23. #endif  

    下面的FunctionPtrT用来根据函数指针的返回类型和各个参数类型构造出函数指针（这里针对最多为5个参数的情况，对含有更多个参数的函数原理和做法是一样的）。最后的FunctionPtr就是真正封装函数指针的仿函数类型，要遵循仿函数的编写约定。它组合一个用FunctionPtrT构造出来的函数指针，然后根据函数指针的不同实参个数（0-5个）重载operator()，并用函数指针来进行调用实际的函数即可。在调用函数时，用到了上面的ForwardParamT<T>，这样就可以在传递调用实参时避免拷贝构造函数的调用。包装函数func_ptr(*fp)用来方便地创建封装了函数指针的函数对象。

[cpp]  view plain copy

1. //functionptr.hpp：把最多为5个参数的函数指针类型封装成仿函数模板FunctionPtr<RT,P1,P2,P3,P4,P5>  
2. //对含有更多个参数的函数，其原理和做法一样的  
3. #ifndef FUNCTION_PTR_HPP  
4. #define FUNCTION_PTR_HPP  
5. #include "forwardparam.hpp"  //用于决定函数的形参T是传引用还是传原来的普通类型  
6. /* 
7.  * FunctionPtrT<RT,P1,P2,P3,P4,P5>：用来根据返回类型和各个参数类型构造出函数指针 
8.  */  
9. template<typename RT, typename P1 = void,   
10.                       typename P2 = void,  
11.                       typename P3 = void,  
12.                       typename P4 = void,  
13.                       typename P5 = void>  
14. class FunctionPtrT{ //基本模板：函数指针有5个参数的情况  
15. public:  
16.     enum { NumParams = 5 }; //定义参数个数的枚举量  
17.     typedef RT (*Type)(P1,P2,P3,P4,P5); //根据参数类型来定义函数指针  
18. };  
19. template<typename RT, typename P1,  
20.                       typename P2,  
21.                       typename P3,  
22.                       typename P4>  
23. class FunctionPtrT<RT,P1,P2,P3,P4,void>{ //局部特化：4个参数的情况  
24. public:  
25.     enum { NumParams = 4 };  
26.     typedef RT (*Type)(P1,P2,P3,P4);  
27. };  
28. template<typename RT, typename P1,  
29.                       typename P2,  
30.                       typename P3>  
31. class FunctionPtrT<RT,P1,P2,P3,void,void>{ //局部特化：3个参数的情况  
32. public:  
33.     enum { NumParams = 3 };  
34.     typedef RT (*Type)(P1,P2,P3);  
35. };  
36. template<typename RT, typename P1,  
37.                       typename P2>  
38. class FunctionPtrT<RT,P1,P2,void,void,void>{ //局部特化：2个参数的情况  
39. public:  
40.     enum { NumParams = 2 };  
41.     typedef RT (*Type)(P1,P2);  
42. };  
43. template<typename RT, typename P1>  
44. class FunctionPtrT<RT,P1,void,void,void,void>{ //局部特化：1个参数的情况  
45.   public:  
46.     enum { NumParams = 1 };  
47.     typedef RT (*Type)(P1);  
48. };  
49. template<typename RT>  
50. class FunctionPtrT<RT,void,void,void,void,void>{ //局部特化：0个参数的情况  
51.   public:  
52.     enum { NumParams = 0 };  
53.     typedef RT (*Type)();  
54. };  
55. /* 
56.  * FunctionPtr<RT,P1,P2,P3,P4,P5>：封装函数指针的仿函数类型 
57.  * 使用缺省的void时表示该参数为空 
58.  */  
59. template<typename RT, typename P1 = void,   
60.                       typename P2 = void,  
61.                       typename P3 = void,  
62.                       typename P4 = void,  
63.                       typename P5 = void>  
64. class FunctionPtr{  
65. private:  
66.     //获得相应的函数指针类型  
67.     typedef typename FunctionPtrT<RT,P1,P2,P3,P4,P5>::Type FuncPtr;  
68.     FuncPtr fptr; //被封装的函数指针  
69. public:  
70.     //保存好参数个数及其各个参数类型  
71.     enum { NumParams = FunctionPtrT<RT,P1,P2,P3,P4,P5>::NumParams };  
72.     typedef RT ReturnT;  
73.     typedef P1 Param1T;  
74.     typedef P2 Param2T;  
75.     typedef P3 Param3T;  
76.     typedef P4 Param4T;  
77.     typedef P5 Param5T;  
78.     FunctionPtr(FuncPtr ptr):fptr(ptr) { //构造函数，创建函数对象，它封装了函数指针  
79.     }  
80.     // 下面是函数调用  
81.     RT operator()() { //0个参数的情况  
82.         return fptr();  
83.     }  
84.     RT operator()(typename ForwardParamT<P1>::Type a1){ //1个参数的情况  
85.         return fptr(a1);  
86.     }  
87.     RT operator()(typename ForwardParamT<P1>::Type a1,  
88.                   typename ForwardParamT<P2>::Type a2){ //2个参数的情况  
89.         return fptr(a1, a2);  
90.     }  
91.     RT operator()(typename ForwardParamT<P1>::Type a1,  
92.                   typename ForwardParamT<P2>::Type a2,  
93.                   typename ForwardParamT<P3>::Type a3){ //3个参数的情况  
94.         return fptr(a1, a2, a3);  
95.     }  
96.     RT operator()(typename ForwardParamT<P1>::Type a1,  
97.                   typename ForwardParamT<P2>::Type a2,  
98.                   typename ForwardParamT<P3>::Type a3,  
99.                   typename ForwardParamT<P4>::Type a4){ //4个参数的情况  
100.         return fptr(a1,a2,a3,a4);  
101.     }  
102.     RT operator()(typename ForwardParamT<P1>::Type a1,  
103.                   typename ForwardParamT<P2>::Type a2,  
104.                   typename ForwardParamT<P3>::Type a3,  
105.                   typename ForwardParamT<P4>::Type a4,  
106.                   typename ForwardParamT<P5>::Type a5){ //5个参数的情况  
107.         return fptr(a1,a2,a3,a4,a5);  
108.     }  
109. };  
110. /* 
111.  * func_ptr(*fp)：包装函数，用于方便地创建封装了函数指针的函数对象 
112.  */  
113. template<typename RT>   
114. inline FunctionPtr<RT> func_ptr(RT (*fp)()){ //0个参数的情况  
115.     return FunctionPtr<RT>(fp);  
116. }  
117. template<typename RT, typename P1>   
118. inline FunctionPtr<RT,P1> func_ptr(RT (*fp)(P1)){ //1个参数的情况  
119.     return FunctionPtr<RT,P1>(fp);  
120. }  
121. template<typename RT, typename P1, typename P2>   
122. inline FunctionPtr<RT,P1,P2> func_ptr(RT (*fp)(P1,P2)){ //2个参数的情况  
123.     return FunctionPtr<RT,P1,P2>(fp);  
124. }  
125. template<typename RT, typename P1, typename P2, typename P3>   
126. inline FunctionPtr<RT,P1,P2,P3> func_ptr(RT (*fp)(P1,P2,P3)){ //3个参数的情况  
127.     return FunctionPtr<RT,P1,P2,P3>(fp);  
128. }  
129. template<typename RT, typename P1, typename P2, typename P3,typename P4>   
130. inline FunctionPtr<RT,P1,P2,P3,P4> func_ptr(RT (*fp)(P1,P2,P3,P4)){ //4个参数的情况  
131.     return FunctionPtr<RT,P1,P2,P3,P4>(fp);  
132. }  
133. template<typename RT, typename P1, typename P2, typename P3,typename P4,typename P5>   
134. inline FunctionPtr<RT,P1,P2,P3,P4,P5> func_ptr(RT (*fp)(P1,P2,P3,P4,P5)){ //5个参数的情况  
135.     return FunctionPtr<RT,P1,P2,P3,P4,P5>(fp);  
136. }  
137. #endif  

    测试代码如下：

[cpp]  view plain copy

1. //functionptrtest.cpp：对封装函数指针的仿函数进行测试  
2. #include <iostream>  
3. #include <string>  
4. #include <typeinfo>  
5. #include "functionptr.hpp"  
6. double seven(){ //0个参数的情况  
7.     return 7.0;  
8. }  
9. std::string more(){ //0个参数的情况  
10.     return std::string("more");  
11. }  
12. int display(int a,int b){ //2个参数的情况  
13.     std::cout<<a<<","<<b<<std::endl;  
14.     return 0;  
15. }  
16. int output(int a,double b,std::string c){ //3个参数的情况  
17.     std::cout<<a<<","<<b<<","<<c<<std::endl;  
18.     return 0;  
19. }  
20. template <typename FunctorT>  
21. void demo(FunctorT func){ //func是封装了函数指针的函数对象，这个函数指针有0个参数  
22.     std::cout << "Functor returns type: "  
23.               << typeid(typename FunctorT::ReturnT).name() << '/n'  
24.               << "Functor returns value: "  
25.               << func() << '/n';  
26. }  
27. int main(){  
28.     demo(func_ptr(seven));  
29.     demo(func_ptr(more));  
30.     func_ptr(display)(123,456);  
31.     func_ptr(output)(83,3.14159,"Jack Zhou");  
32.     return 0;  
33. }  

    3、仿函数的组合： Composer<FO1,FO2>用来组合两个仿函数的使用，先调用仿函数FO1（其参数个数可以是0-20个），再把其返回的结果的用作实参来调用仿函数FO2。可见FO2只能有一个参数，且与FO1的返回类型相同，这样才能组合使用。包装函数compose(f1,f2)用来方便地创建两个仿函数的组合对象。

[cpp]  view plain copy

1. //composer.hpp：Composer<FO1,FO2>用于组合两个仿函数的使用  
2. #ifndef COMPOSER_HPP  
3. #define COMPOSER_HPP  
4. #include "forwardparam.hpp"  //用于决定函数的形参T是传引用还是传原来的普通类型  
5. #include "functorparam.hpp"  //用于获取仿函数各个参数的类型  
6. /* 
7.  * BaseMem<C,N>：为了避免Composer多次继承同一个类而引入的间接层 
8.  */  
9. template <typename C, int N>   
10. class BaseMem : public C { //直接继承模板参数C（是一个仿函数类）  
11. public:  
12.     BaseMem(C& c) : C(c) { }  
13.     BaseMem(C const& c) : C(c) { }  
14. };  
15. /* 
16.  * Composer<FO1,FO2>：组合两个仿函数FO1、FO2，先调用FO1，再调用FO2 
17.  * 通过BaseMem间接继承FO1和FO2，这样当FO1或FO2为空类是就可以进行空基类优化 
18.  */  
19. template <typename FO1, typename FO2>  
20. class Composer : private BaseMem<FO1,1>,  
21.                  private BaseMem<FO2,2>{  
22. public:  
23.     enum { NumParams = FO1::NumParams }; //参数个数  
24.     typedef typename FO2::ReturnT ReturnT; //最后的返回类型  
25.     //用FunctorParam来获取仿函数FO1的各个参数类型，  
26.     //作为Composer的各个参数Param1T, Param2T,...  
27.     // 用宏来简化参数类型的定义  
28.     #define ComposeParamT(N)      /  
29.     typedef typename FunctorParam<FO1, N>::Type Param##N##T;  
30.       
31.     //假设N到20为止，很少有多于20个参数的仿函数  
32.     ComposeParamT(1)  
33.     ComposeParamT(2)  
34.     ComposeParamT(3)  
35.     //...  
36.     ComposeParamT(20)  
37.     #undef ComposeParamT  
38.     //构造函数：组合两个仿函数对象，这里考虑了各种const和非const的情况  
39.     //把两个仿函数对象存储在基类子对象中，这就允许进行空基类优化  
40.     Composer(FO1 const& f1, FO2 const& f2)  
41.      : BaseMem<FO1,1>(f1), BaseMem<FO2,2>(f2) {  
42.     }  
43.     Composer(FO1 const& f1, FO2& f2)  
44.      : BaseMem<FO1,1>(f1), BaseMem<FO2,2>(f2) {  
45.     }  
46.     Composer(FO1& f1, FO2 const& f2)  
47.      : BaseMem<FO1,1>(f1), BaseMem<FO2,2>(f2) {  
48.     }  
49.     Composer(FO1& f1, FO2& f2)  
50.      : BaseMem<FO1,1>(f1), BaseMem<FO2,2>(f2) {  
51.     }  
52.     //针对0个参数的函数调用  
53.     ReturnT operator() (){ //针对0个参数的函数调用  
54.       return BaseMem<FO2,2>::operator()(BaseMem<FO1,1>::operator()());  
55.     }  
56.     //针对1个参数的函数调用  
57.     ReturnT operator() (typename ForwardParamT<Param1T>::Type v1) {  
58.         return BaseMem<FO2,2>::operator()(BaseMem<FO1,1>::operator()(v1));  
59.     }  
60.     //针对2个参数的函数调用  
61.     ReturnT operator() (typename ForwardParamT<Param1T>::Type v1,  
62.                         typename ForwardParamT<Param2T>::Type v2) {  
63.         return BaseMem<FO2,2>::operator()(BaseMem<FO1,1>::operator()(v1, v2));  
64.     }  
65.     //针对3个参数的函数调用  
66.     ReturnT operator() (typename ForwardParamT<Param1T>::Type v1,  
67.                         typename ForwardParamT<Param2T>::Type v2,  
68.                         typename ForwardParamT<Param3T>::Type v3) {  
69.         return BaseMem<FO2,2>::operator()(BaseMem<FO1,1>::operator()(v1, v2,v3));  
70.     }  
71.       
72.     //...  
73.     //一直写到针对20个参数的函数调用  
74. };  
75. /* 
76.  * compose(f1,f2)包装函数：用于方便地创建两个仿函数的组合 
77.  */  
78. template <typename FO1, typename FO2>  
79. inline Composer<FO1,FO2> compose(FO1 f1, FO2 f2) {  
80.     return Composer<FO1,FO2> (f1, f2);  
81. }  
82. #endif  

[cpp]  view plain copy

1. //composertest.cpp：对仿函数组合的测试  
2. #include <iostream>  
3. #include "composer.hpp"  
4. #include "functionptr.hpp"  
5. double add(double a, double b){  
6.     return a+b;  
7. }  
8. double twice(double a){  
9.     return 2*a;  
10. }  
11. int main(){  
12.     std::cout << "compute (20+7)*2: "  
13.               << compose(func_ptr(add),func_ptr(twice))(20,7)  
14.               << '/n';  
15.     return 0;  
16. }  

    解释：
    （1）这里让Composer<FO1,FO2>通过BaseMem间接继承模板参数FO1,FO2，以便当FO1和FO2为空类时可以进行空基类优化。如果Composer直接继承FO1和FO2，当FO1和FO2为同一个类型时，编译会出错，因此我们需要要引入间接层BaseMem，现在的基类BaseMem<FO1,1>和BaseMem<FO2,2>并不是同一个类型。
    （2）Composer是仿函数类，需要遵循仿函数的编写约定。它的各个参数类型是FO1的各个参数类型。因此我们需要用FunctorParam来抽取仿函数FO1的各个参数类型，以作为Composer的各个参数Param1T, Param2T,...,Param20T。
    （3）构造函数用于组合两个仿函数对象，它需要考虑两个仿函数的const和非const的情况。下面的函数调用运算符中是先调用FO1，把返回结果作为实参再调用FO2。
    4、仿函数参数的值绑定： 即将仿函数的某个参数绑定为一个特定的值，这样仿函数的参数就可以减少一个。我们需要开发出一个绑定器（是一个仿函数）来作绑定操作，一个独立的类来存放绑定值。绑定器的各个参数类型萃取也比较麻烦，它需要去掉仿函数中被绑定的参数，然后后面的参数又要前移一个位置，因此我们把绑定器的参数类型萃取抽离出来设计成一个独立的模板。    
    下面的BoundVal<T>用于在运行期存放T类型的绑定值（这个值后面会被绑定到仿函数的某个参数上去），而StaticBoundVal<T> 则用于在编译期存放T类型的绑定值。

[cpp]  view plain copy

1. //boundval.hpp：存放绑定值的模板，可通过get()来获取这个绑定值  
2. #ifndef BOUND_VAL_HPP  
3. #define BOUND_VAL_HPP  
4. #include "typeop.hpp"  
5. template <typename T>  
6. class BoundVal{ //在运行期存放T类型的绑定值  
7. private:  
8.     T value; //存放绑定值的对象  
9. public:  
10.     typedef T ValueT;  
11.     BoundVal(T v):value(v){ //把要绑定的值通过构造函数传进来  
12.     }  
13.     typename TypeOp<T>::RefT get(){ //设置或获取绑定的值  
14.         return value;  //返回非const的引用  
15.     }  
16. };  
17. template <typename T, T Val>  
18. class StaticBoundVal{ //在编译期存放T类型的绑定值  
19.   public:  
20.     typedef T ValueT;  
21.     T get(){ //通过get()来获取绑定的值  
22.         return Val;   
23.     }  
24. };  
25. #endif  

    下面的BinderParams<F,P>用来萃取绑定器的参数类型。它只要去掉仿函数中被绑定的参数， 并把后面的参数前移1个位置即可。

 

[cpp]  view plain copy

1. //binderparams.hpp：绑定器的参数类型列表，去掉仿函数中被绑定的参数，  
2. //并把后面的参数前移1个位置即可  
3. #ifndef BINDER_PARAMS_HPP  
4. #define BINDER_PARAMS_HPP  
5. #include "ifthenelse.hpp"  
6. /* 
7.  * BinderParams<F,P>：用于将被绑定参数（即第P个参数）后面的参数前移1个位置 
8.  * BinderParams<F,P>::ParamNT：仿函数F被绑定后的第N个参数类型 
9.  */  
10. template<typename F, int P>  
11. class BinderParams{  
12. public:  
13.     enum { NumParams = F::NumParams-1 };//一个参数已绑定，故参数个数减1  
14.       
15.     //将被绑定参数（即第P个参数）后面的参数前移1个位置  
16.     #define ComposeParamT(N)                                   /  
17.     typedef typename IfThenElse<(N<P), FunctorParam<F, N>,     /  
18.                                        FunctorParam<F, N+1>    /  
19.                                >::ResultT::Type                /  
20.             Param##N##T;  
21.               
22.     //假设N到20为止，很少有多于20个参数的仿函数  
23.     ComposeParamT(1)  
24.     ComposeParamT(2)  
25.     ComposeParamT(3)  
26.     //...  
27.     ComposeParamT(20)  
28.       
29.     #undef ComposeParamT  
30. };  
31. #endif  

    下面的SignSelectT<S,NegT,ZeroT,PosT>根据整数S是正、0、还是负来选择相应的类型。

[cpp]  view plain copy

1. //signselect.hpp：根据整数S是正、0、还是负来选择相应的类型  
2. #ifndef SIGN_SELECT_HPP  
3. #define SIGN_SELECT_HPP  
4. #include "ifthenelse.hpp"  
5. template <int S, typename NegT, typename ZeroT, typename PosT>  
6. struct SignSelectT{  
7.   typedef typename  
8.       IfThenElse<(S<0),  
9.                  NegT,   
10.                  typename IfThenElse<(S>0),  
11.                                      PosT,  
12.                                      ZeroT  
13.                                     >::ResultT  
14.                 >::ResultT  
15.       ResultT;  
16. };  
17. #endif  

    下面是真正的绑定器Binder<FO,P,V>。它把仿函数FO的第P个参数绑定为一个存放在V类型对象中的绑定值，绑定后它还要完成对仿函数FO的调用，即Binder<FO,P,V>本身就相当于被绑定后的FO。Binder的参数类型列表Params是仿函数FO去掉绑定参数后的各个参数类型，可见Binder::operator()的参数个数比底层的FO::operator()少一个，因此它在调用底层的FO::operator()时需要重新确定原来FO的参数，并指定一个参数为绑定值。嵌套类模板ArgSelect<A>就是用来确定FO的各个实参。包装函数bind<P>(fo,val)用于方便地将仿函数对象fo的第P个参数绑定为值val。

[cpp]  view plain copy

1. //binder.hpp：用于对仿函数的参数进行值绑定  
2. #ifndef BINDER_HPP  
3. #define BINDER_HPP  
4. #include "ifthenelse.hpp"  
5. #include "typeop.hpp"  
6. #include "boundval.hpp"     //用于存放要绑定的值  
7. #include "forwardparam.hpp" //用于决定仿函数的形参T是传引用还是传原来的普通类型  
8. #include "functorparam.hpp" //获取仿函数各个参数的类  
9. #include "binderparams.hpp" //用于将被绑定参数后面的参数前移1个位置  
10. #include "signselect.hpp"   //根据整数的正负性来选择相应的类型  
11. /* 
12.  * Binder<FO,P,V>：把仿函数FO的第P个参数绑定为一个存放在V类型对象中的绑定值， 
13.  * V是BoundVal<T>或StaticBoundVal<T,val>类型，里面存放了真正 
14.  * 的绑定值（是T类型的） 
15.  */  
16. template <typename FO, int P, typename V>  
17. class Binder : private FO, private V{  
18. public:     
19.     enum { NumParams = FO::NumParams-1 }; //一个参数已经绑定，故参数个数减1  
20.     typedef typename FO::ReturnT ReturnT; //返回类型  
21.     typedef BinderParams<FO, P> Params; //参数类型列表：Params中含有仿函数FO  
22.                                         //去掉绑定参数后的各个参数类型  
23.       
24.     //定义Binder需要的各个参数类型（或者为原来类型的const引用，或者为原来的普通类型）  
25.     #define ComposeParamT(N)                                           /  
26.     typedef typename ForwardParamT<typename Params::Param##N##T>::Type /  
27.             Param##N##T;  
28.     ComposeParamT(1)  
29.     ComposeParamT(2)  
30.     ComposeParamT(3)  
31.     //...  
32.     ComposeParamT(20)  
33.       
34.     #undef ComposeParamT  
35.     //构造函数：根据传过来的仿函数对象和存放了绑定值的V类型对象构造Binder，  
36.     //这里考虑了各种const和非const的情况  
37.     Binder(FO& f): FO(f) {}  
38.     Binder(FO& f, V& v): FO(f), V(v) {}  
39.     Binder(FO& f, V const& v): FO(f), V(v) {}  
40.     Binder(FO const& f): FO(f) {}  
41.     Binder(FO const& f, V& v): FO(f), V(v) {}  
42.     Binder(FO const& f, V const& v): FO(f), V(v) {}  
43.       
44.     //构造函数模板：直接根据仿函数对象和要绑定的值（T类型的）构造Binder，绑定的值存储在  
45.     //BoundVal<T>中，即在运行期存储绑定值  
46.     template<class T>  
47.     Binder(FO& f, T& v): FO(f), V(BoundVal<T>(v)) {}  
48.       
49.     template<class T>  
50.     Binder(FO& f, T const& v): FO(f), V(BoundVal<T const>(v)) {}  
51.     //函数调用：对调用实参个数不同的情况，都要重载调用运算符  
52.     //Binder::operator()的参数个数比底层的FO::operator()少一个  
53.     ReturnT operator()(){   
54.         return FO::operator()(V::get());  
55.     }  
56.     ReturnT operator()(Param1T v1){  
57.         //根据实参位置（1和2）与P的相对位置，用from函数自动选择是使用用户  
58.         //提供的v1，还是使用被绑定的值V::get()  
59.         return FO::operator()(ArgSelect<1>::from(v1,v1,V::get()),  
60.                               ArgSelect<2>::from(v1,v1,V::get()));  
61.     }  
62.     ReturnT operator()(Param1T v1, Param2T v2){  
63.         return FO::operator()(ArgSelect<1>::from(v1,v1,V::get()),  
64.                               ArgSelect<2>::from(v1,v2,V::get()),  
65.                               ArgSelect<3>::from(v2,v2,V::get()));  
66.     }  
67.     ReturnT operator()(Param1T v1, Param2T v2, Param3T v3) {  
68.         return FO::operator()(ArgSelect<1>::from(v1,v1,V::get()),  
69.                               ArgSelect<2>::from(v1,v2,V::get()),  
70.                               ArgSelect<3>::from(v2,v3,V::get()),  
71.                               ArgSelect<4>::from(v3,v3,V::get()));  
72.     }  
73.     //...  
74.     //一直写到针对20个参数的函数调用  
75. private:  
76.     template<int A>  
77.     class ArgSelect{ //私有的嵌套类模板：实参选择器，用来确定FO原来的各个实参  
78.     public:  
79.         //定义绑定实参前面的类型：FO的第A个参数类型ArgSelect<A>::NoSkipT恰为  
80.         //Binder的第A个参数类型（取其引用类型），当A达到比NumParams多1时，退回到Binder的A-1处  
81.         typedef typename TypeOp<  
82.                     typename IfThenElse<(A<=Params::NumParams),  
83.                                         FunctorParam<Params, A>,  
84.                                         FunctorParam<Params, A-1>  
85.                                        >::ResultT::Type>::RefT  
86.                 NoSkipT;  
87.                   
88.         //定义绑定实参后面的类型：FO的第A个参数类型ArgSelect<A>::SkipT恰为  
89.         //Binder的第A-1个参数类型（取其引用类型），当A为1时，前移到Bindder的A处  
90.         //ArgSelect<A>::NoSkipT  
91.         typedef typename TypeOp<  
92.                     typename IfThenElse<(A>1),  
93.                                         FunctorParam<Params, A-1>,  
94.                                         FunctorParam<Params, A>  
95.                                        >::ResultT::Type>::RefT  
96.                 SkipT;  
97.                   
98.         //定义绑定实参处的类型：在存放绑定值的V类型中有记录  
99.         typedef typename TypeOp<typename V::ValueT>::RefT BindT;  
100.         //3个不同的嵌套类，用来实现3种情况下FO实参值的选择  
101.         class NoSkip{ //选择绑定参数前面的实参：为用户指定的实参  
102.         public:  
103.             static NoSkipT select(SkipT prev_arg, NoSkipT arg,  
104.                                    BindT bound_val) {  
105.                 return arg;  
106.             }  
107.         };  
108.         class Skip{ //选择绑定参数后面的实参：为用户指定的实参  
109.         public:  
110.             static SkipT select(SkipT prev_arg, NoSkipT arg,  
111.                                  BindT bound_val){  
112.                 return prev_arg;  
113.             }  
114.         };  
115.         class Bind{ //选择绑定参数处的实参：为绑定值  
116.         public:  
117.             static BindT select(SkipT prev_arg, NoSkipT arg,  
118.                                  BindT bound_val){  
119.                 return bound_val;  
120.             }  
121.         };  
122.         //根据A与P的相对位置返回仿函数FO中A处的参数类型  
123.         typedef typename SignSelectT<A-P, NoSkipT,  
124.                                      BindT, SkipT>::ResultT  
125.                 ReturnT;  
126.                   
127.         //根据A与P的相对位置返回仿函数FO的实参选择类（上面的3个嵌套类之一，用来  
128.         //选择FO在A处的实参值）  
129.         typedef typename SignSelectT<A-P, NoSkip,  
130.                                      Bind, Skip>::ResultT  
131.                 SelectedT;  
132.                   
133.         //实际的选择函数：  
134.         static ReturnT from (SkipT prev_arg, NoSkipT arg,   
135.                              BindT bound_val){  
136.             //根据获得的选择类，调用select来选择相应的实参值  
137.             return SelectedT::select(prev_arg, arg, bound_val);  
138.         }  
139.     };  
140. };  
141. /* 
142.  * 包装函数bind<P>(fo,val)：将仿函数对象fo的第P个参数绑定为值val 
143.  * FO可演绎出来，FunctorParam<FO,P>::Type为绑定值的类型 
144.  * BoundVal<typename FunctorParam<FO,P>::Type>为存放绑定值的V类型 
145.  * ForwardParamT可用来决定val是传引用还是传原来的类型 
146.  */  
147. template <int P,typename FO>     //P为绑定参数的位置，FO为仿函数  
148. inline Binder<FO,P,BoundVal<typename FunctorParam<FO,P>::Type> >  
149. bind(FO const& fo,   
150.       typename ForwardParamT<typename FunctorParam<FO,P>::Type>::Type val){  
151.     //返回一个对fo进行绑定后的Binder仿函数对象  
152.     return Binder<FO,  
153.                   P,  
154.                   BoundVal<typename FunctorParam<FO,P>::Type>  
155.                  >(fo,BoundVal<typename FunctorParam<FO,P>::Type>(val));  
156. }  
157. #endif  

    解释：
    （1）Binder继承自模板参数FO和V，这样就可以使用空基类优化技术。Binder是一个仿函数，因此它要遵循仿函数的编写约定，定义参数个数和各个参数类型（用上面的BinderParams来萃取）。
    （2）构造函数根据传过来的仿函数对象和存放了绑定值的V类型对象构造Binder，它需要考虑各种const和非const的情况。而构造函数模板则直接根据仿函数对象和要绑定的值（T类型的）构造Binder，绑定的值存储在BoundVal<T>中，即在运行期存储绑定值。
    （3）ArgSelect<A>用来确定原来FO的各个实参，这样才能在Binder中完成对被绑定的FO的调用。它先根据A的位置定义绑定实参前面的类型NoSkipT、绑定实参后面的类型SkipT、以及绑定实参处的类型BindT。然后定义3个不同的嵌套类，里面有一个静态的select函数，用来实现3种情况下对FO实参值的选择。接着根据A与P的相对位置，用SignSelectT得到仿函数FO中A处的参数类型、以及仿函数FO的实参选择类（即上面的的3个嵌套类之一）。最后是真正的实参选择函数from，它调用相应选择类的select，根据实参位置A与P的相对位置，自动选择FO中A处是使用用户提供的实参，还是使用被绑定的值。
    （4）函数调用Binder::operator()对调用实参个数不同的情况，都要进行重载。Binder::operator()直接调用FO::operator()，而各个实参是根据所在位置用ArgSelect<n>::from来自动选择，对FO中绑定处的参数用绑值V::get()，对其他位置的参数则用用户传递过来的实参。
    （5）包装函数bind<P>(fo,val)直接返回一个对fo绑定后的少了一个参数的仿函数对象。它的使用就相当于对少了一个参数的fo的使用。
    测试代码如下：

[cpp]  view plain copy

1. //bindertest.cpp：对绑定器Binder的测试  
2. #include <string>  
3. #include <iostream>  
4. #include "functionptr.hpp"  
5. #include "binder.hpp"  
6. //这个函数会被func_ptr封装为仿函数  
7. bool func(std::string const& str, double d, float f){  
8.     std::cout << str << ": "   
9.               << d << (d<f? "<": ">=")   
10.               << f << '/n';  
11.     return d<f;  
12. }  
13. int main(){  
14.     //把仿函数func_ptr(func)的第1个参数绑定为"Comparing"  
15.     bool result = bind<1>(func_ptr(func), "Comparing")(1.0, 2.0);  
16.     std::cout << "bound function returned " << result << '/n';  
17.     return 0;  
18. }  

    5、普通函数参数的值绑定： 可先用上面的func_ptr(*fp)把函数（最多只能接受5个参数）封装成仿函数，再用bind来进行值绑定即可。上面的测试代码中就是这样用的。从中我们可以看出，通过使用func_ptr和bind的实现，我们可以对任意普通函数的参数进行值绑定。

============================================================================

我的C++实践(13)：多态化的构造函数和非成员函数

转自 http://blog.csdn.net/zhoudaxia/article/details/4550898

    我们知道构造函数和非成员函数函数不可能是虚函数，但有时候当我们使用一个继承体系时，又希望这些函数具有多态行为，能根据基类指针（或引用）自动地使用子类的实现。其实，通过一些设计技术，我们可以达到这样的目的。
    1、虚构造函数： 完成对象的创建，并返回基类指针的函数。它的功能就是创建对象，但具有了多态行为，这种虚构造函数有很多的应用。
    设想写一个时事通讯(newsletter)的程序，组成NewsLetter的元素是文本TextBlock和图片Graphic，所有元素都从抽象基类NLComponent派生。图片和文本的内容在硬盘（或网络）上，这样TextBlock和Graphic的构造函数需要根据输入流来构造对象。代码如下：

[cpp]  view plain copy

1. //newsletter1.hpp：处理时事通讯的程序，时事通讯包含的组件有文本和图片  
2. //有多态化的构造函数  
3. #ifndef NEWSLETTER_HPP  
4. #define NEWSLETTER_HPP  
5. #include <list>  
6. #include <iostream>  
7. class NLComponent{ //抽象基类  
8. public:  
9.     //至少有一纯虚函数  
10. };  
11. class TextBlock : public NLComponent{ //文本  
12. public:  
13.     TextBlock(std::istream& in){  
14.         //用in中的文本数据初始化各个成员  
15.     }  
16.     //...  
17.     }  
18. };  
19. class Graphic : public NLComponent{ //图片  
20. public:  
21.     Graphic(std::istream& in){  
22.         //用in中的图片数据初始化各个成员  
23.     }  
24.     //...  
25. };  
26. inline NLComponent* constructComponent(std::istream& in){//多态化的构造函数  
27.     //用一个变量data保存in中的数据  
28.     if(/* str是文本数据 */)  
29.         return new TextBlock(in);  
30.     if(/* str是文本数据 */)  
31.         return new Graphic(in);  
32.     //...  
33.       
34.     //默认情况返回文本数据  
35.     return new TextBlock(in);  
36. }  
37. class NewsLetter{ //时事通讯  
38. private:  
39.     std::list<NLComponent*> components;    //存储了各个文本或图片  
40. public:  
41.     NewsLetter(std::istream& in);  
42.     //...  
43. };  
44. NewsLetter::NewsLetter(std::istream& in){ //多态化的构造函数  
45.     while(in){ //不断地从流中读数据  
46.         //用虚构造函数构造对象，然后加入到components列表中  
47.         components.push_back(construtComponent(in));  
48.     }  
49. }  
50. #endif  

 

    这里的constructComponent就是所谓的虚构造函数。我们在NewLetter中需要创建所有的数据成员（各个元素对象），并把指针压入components列表中。但components列表中只需压入NLComponent*型的指针，无需知道这个指针所指对象的确切子类型，这就需要各个子类的构造函数具有多态行为，希望它们能返回基类指针。但我们知道类的构造函数不能为虚函数，因此我们把对象的创建工作封装成constructComponent函数，它根据所读取的不同数据来创建不同的子类对象，并返回一个NLComponent*指针。为避免封装带来的效率损失，我们把它声明为inline。constructComponent中一般有一个分支语句，根据所读取数据的不同，创建相应的对象。constructComponent充当了真正构造函数的多态版本，它具有多态行为，因此可称为虚构造函数。这里constructComponent是全局函数，我们也可以把它实现为NewsLetter类的静态成员函数。如果我们不想动态分配资源，则在constructComponent中不用new，返回时用基类引用即可。
    虚构造函数的实现思想： 在继承体系中定义一个全局函数，它用来根据一个标志构造相应的子类对象，并返回指向它的基类指针。这样这个全局函数相当于一个构造函数，又具有了多态行为。
    2、虚拷贝构造函数： 当我们要对基类指针所指对象进行拷贝时，可能不知道指针所指向的到底是那个子类对象，因此无法调用子类的拷贝构造函数。这就需要在继承体系的基类中指定一个统一的接口（一般是名为clone的虚函数），用来实现拷贝功能。每个子类重写clone()，它直接调用实际的拷贝构造函数拷贝*this，返回这个副本的指针。子类中的clone()虽然返回本子类的指针，但根据C++标准，它仍然是重写了基类的clone版本（基类中的版本返回基类指针）。clone()就相当于虚拷贝构造函数，它具有多态行为，因为可以用基类指针来指向这个返回的副本。
    例如对于NewsLetter的拷贝，我们需要拷贝components列表，由于里面存放的是NLComponent*指针，因此要作深拷贝。即我们要把指针所指的各个对象拷贝过来，这需要调用对象的拷贝构造函数，但我们不并知道对象的具体子类型，因此需要在继承体系中提供clone()函数来实现这个功能。

[cpp]  view plain copy

1. //newsletter2.hpp：处理时事通讯的类，时事通讯包含的组件有文本和图片  
2. //有多态化的拷贝构造函数  
3. #ifndef NEWSLETTER_HPP  
4. #define NEWSLETTER_HPP  
5. #include <list>  
6. class NLComponent{ //抽象基类  
7. public:  
8.     virtual NLComponent* clone() const=0;  
9.     //...  
10. };  
11. class TextBlock : public NLComponent{  
12. public:  
13.     virtual TextBlock* clone() const{ //多态化的拷贝构造函数  
14.         return new TextBlock(*this);  
15.     }  
16.     //...  
17. };  
18. class Graphic : public NLComponent{  
19. public:  
20.     virtual Graphic* clone() const{  
21.         return new Graphic(*this);  
22.     }  
23.     //...  
24. };  
25. class NewsLetter{  
26. private:  
27.     std::list<NLComponent*> components;  
28. public:  
29.     NewsLetter(){ }  
30.     NewsLetter(NewsLetter const& rhs);  
31.     //...  
32. };  
33. NewsLetter::NewsLetter(NewsLetter const& rhs){ //NewsLetter的拷贝构造函数  
34.     //注意访问控制是针对类与类之间的，而不是针对同类的不同对象  
35.     //因此rhs的components虽为private，但components是NewsLetter类中的成员，  
36.     //现在已经在NewLetter的作用域中，因此可以访问  
37.     for(std::list<NLComponent*>::const_iterator it=rhs.components.begin();  
38.         it!=rhs.components.end();++it){  
39.         components.push_back((*it)->clone()); //使用了虚的拷贝构造函数  
40.     }  
41. }  
42. #endif  

[cpp]  view plain copy

1. //newsletter2test.cpp：对多态化的拷贝构造函数的测试  
2. #include "newsletter2.hpp"  
3. #include <iostream>  
4. int main(){  
5.     NewsLetter news;  
6.     NewsLetter let(news); //调用NewsLetter的拷贝构造函数  
7.     std::cout<<"Yes"<<'/n';  
8.     return 0;  
9. }  

    在继承体系中，我们添加了一个clone()虚函数，各个子类都要实现clone()函数。现在，即使指针不知道所指向的到底是那个子类对象，但它知道所有的子类都有一个clone()函数，用它可以完成拷贝功能，因此只要调用clone()就可以了，clone()相当于拷贝构造函数的多态版本，同时它又是内联的，基本上没有性能损失。事实上，在Java、C#这样的语言中就使用了这种技术（它们的类继承体系中有一个clone函数）。
    思想总结： 从中我们可以看出，多态机制最大的好处就是让我们可以用统一的标记（基类指针或引用）来关联不同的行为（各个子类中重写的虚函数），但它也会产生副作用。它隐藏了指针（或引用）所指对象的类型，使得我们有时候不能对所指对象进行一些具体的操作。这就需要我们在继承体系的基类中指定一个统一的接口，各个子类必须重写这个接口，完成我们需要的具体操作。有了这个契约，即使我们不知道对象的具体类型，但我们知道每个类都有一个统一的接口来完成相应的操作。 
    多态还有一些其他的副作用。比如把多态应用于数组时，就会出问题。如果我们用基类指针（或引用）来指向一个包含派生类对象的数组，编译器就会认为数组中的每个对象的大小都和基类一样，在对数组进行遍历时，指针的移动（array[i]相当于*(array+i)，对指针进行运算）会导致获得的对象地址不准确。另外，在用delete[]删除数组也同样有这样的问题，因为delete[]也要遍历数组的各个元素来调用它们的析构函数，这同样通过作指针移动运算来计算偏移地址。一般地，多态和指针运算就是不能用在一起，在数组中最好不要使用多态。要避免这个问题，我们在做设计时应尽量少从具体类派生出具体类，而让一个类派生自抽象基类，这样我们就不太可能犯这种把多态应用于数组的错误。另一种方法是少用或不用数组，多用std::vector、std::list等容器。当我们需要数组多态时，使用容器来存放基类指针，这还能让它们指向不同子类的对象。在上面的实现中，我们就使用了std::list来存放NLComponent*型指针，这样就可以实现安全的多态行为。
    3、虚的非成员函数： 非成员函数不可能是虚函数，但根据函数的参数（是某个基类指针或引用），可以让非成员函数具有多态行为。只要在参数类型的各个子类中用统一的虚函数来完成实际任务，然后让非成员函数调用这个虚函数即可。由于虚函数是多态的，这就导致非成员函数也有了多态行为。
    比如我们希望时事通讯的各个元素类具有输出功能，能够输出文本或图片的内容。显而易见的做法是让它们重载输出运算符<<，只要在抽象基类NLComponent中声明operator<<这个统一的虚接口，所有子类就必须实现它。在应用时只要写成"cout<<基类引用"，就可以自动调用相应子类的operator<<，输出相应的内容。但是我们知道operator<<通常并不把它重载为成员函数，如果要重载为成员函数，就只能写成“ostream& operator<<(ostream& out)”的形式，使用的形式是“t<<cout“，t为TextBlock或Graphic对象，这与传统使用习惯正好相反。因此operator<<一般重载为非成员函数，但又要让它具有多态行为，怎么办呢？我们可以在继承体系中实现一个统一的虚函数接口用于打印输出，然后让operator<<非成员函数调用它即可。

[cpp]  view plain copy

1. //newsletter3.hpp：处理时事通讯的类，有多态化的非成员函数  
2. #ifndef NEWSLETTER_HPP  
3. #define NEWSLETTER_HPP  
4. #include <iostream>  
5. #include <list>  
6. class NLComponent{ //抽象基类  
7. public:  
8.     //用于打印输出  
9.     virtual std::ostream& print(std::ostream& out) const=0;  
10. };  
11. class TextBlock : public NLComponent{  
12. public:  
13.     virtual std::ostream& print(std::ostream& out) const{  
14.         //输出文本内容  
15.     }  
16.     virtual TextBlock* clone() const{ //多态化的拷贝构造函数  
17.         return new TextBlock(*this);  
18.     }  
19.     //...  
20. };  
21. class Graphic : public NLComponent{  
22. public:  
23.     virtual std::ostream& print(std::ostream& out) const{  
24.         //输出图片内容  
25.     }  
26.     virtual Graphic* clone() const{  
27.         return new Graphic(*this);  
28.     }  
29.     //...  
30. };  
31. class NewsLetter{  
32. private:  
33.     std::list<NLComponent*> components;  
34. public:  
35.     NewsLetter(){ }  
36.     //...  
37. };  
38. //非成员函数：具有虚函数的行为  
39. inline std:ostream& operator<<(std::ostream& out,NLComponent const& c){  
40.     return c.print(out); //自动绑定到子类的print上  
41. }  
42. #endif  

 

    这里的统一接口print函数完成实际的打印输出功能，它其实就相当于成员函数版的operator<<，只不过函数名改成了print。非成员函数operator<<直接根据基类引用调用print，这就获得了多态行为。

==================================================================================

我的C++实践(14)：限制类对象的个数

转自 http://blog.csdn.net/zhoudaxia/article/details/4555847

    1、允许一个或零个对象： 把所有的构造函数声明为私有，则不能创建任何对象。如果允许只创建一个对象，可用一个全局函数（或静态成员函数）来创建唯一的一个静态对象，并返回其引用，为提高效率，可把全局函数声明为inline。注意这个全局函数要声明为类的友元函数，因为要使用私有的构造函数。
    例如我们想创建一个打印机对象，但希望实际上只有一个打印机，可以这样写：

[cpp]  view plain copy

1. //printer.hpp：只允许创建一个打印机对象，即单例模式  
2. #ifndef PRINTER_HPP  
3. #define PRINTER_HPP  
4. class PrintJob{  
5. public:  
6.     PrintJob(const string& whatToPrint){  
7.         //...  
8.     }  
9.     //...  
10. };  
11. class Printer{ //打印机类  
12. private:  
13.      //所有构造函数都声明为私有，则不能作为基类使用  
14.     Printer(){  
15.         //...  
16.     }  
17.     Printer(Printer const& rhs){  
18.         //...  
19.     }  
20.     friend Printer& thePrinter();  
21.     //...  
22. public:  
23.     void submitJob(PrintJob const& job){  
24.         //...  
25.     }  
26.     void reset(){  
27.         //...  
28.     }  
29.     void performSelfTest(){  
30.         //...  
31.     }  
32.     //...  
33. };  
34. inline Printer& thePrinter(){ //获取唯一的一个打印机对象  
35.     static Printer p;  
36.     return p;  
37. }  
38. //...  
39. #endif  

 

    这里我们把thePrinter()实现为一个全局函数，里面只创建一个静态对象，返回其引用，这样客户端代码中的所有thePrinter()调用都只使用这个唯一的静态对象。注意，对构造函数，可以只声明为私有，如果不使用它，则可以不提供定义，但对需要被使用的构造函数（因为是私有，只能在类的成员函数或友元函数中使用）则必须提供定义。当然，我们也可以把thePrinter()实现为Printer类的静态成员函数，这样就不需要友元声明了。但使用全局函数也有优势，因为在某些类中声明的静态对象即使没用到也会被构造（以及析构）出来，而全局函数里的静态对象只有执行函数时才被创建。
    另一方面，我们有时候会把那个唯一的p对象声明为全局的静态对象或Printer类的静态成员，然后在thePrinter()或Printer::thePrinter()中直接返回它，这不是一种好的实现方案。我们称函数内的static对象称为local static对象，其他的static对象（class作用域、namespace作用域、global作用域、file作用域）称为non-local static对象。C++只保证在一个特定编译单元内的静态对象的初始化顺序，对不同编译单元内的non-local static对象的初始化次序没有明确定义。可见这样的实现方案会使得p对象的初始顺序不明确。
    当我们需要用到non-local static对象，又要保证正确的初始化顺序时，解决方法恰恰就是将non-local static对象放在一个inline包装函数中，函数返回一个引用指向此对象（变成local static对象）。用函数调用来替换直接访问non-local static对象，这时函数内的局部静态对象就会有确定的初始化顺序（在第一次执行函数时初始化）。注意，我们通常在设计时并不建议返回指向函数内局部对象的reference，但这里的包装函数行为单纯，只是包装一个static对象并返回其reference，并不做其他工作。当多次调用包装函数时，reference指向同一个static对象，并且值均相同（包装函数内并没有改变对象的成员值），因此这样实现没有副作用。
    注意，构造函数声明为私有的类不能作为基类使用，也不能组合到其他类中来使用。我们可以放宽一点，把构造函数声明为protected的，这样类同样不可以创建对象，但可以被继承。
    2、允许创建任意数量的对象，但不允许作为基类： 把构造函数声明为私有，这样就不允许作为基类了。同时我们提供相应的伪构造函数，用它来创建对象并返回。例如对有限状态机类，如下：

[cpp]  view plain copy

1. //fsa.hpp：有限状态机类，允许创建任意数量的对象，但不允许作为基类  
2. #ifndef FSA_HPP  
3. #define FSA_HPP  
4. class FSA{ //有限状态机类  
5. private:  
6.     //构造函数声明为私有  
7.     FSA(){  
8.         //...  
9.     }  
10.     FSA(FSA const& rhs){  
11.         //...  
12.     }  
13. public:  
14.     static FSA* makeFSA(){  //伪构造函数  
15.         return new FSA();  
16.     }  
17.     static FSA* makeFSA(FSA const& rhs){ //伪拷贝构造函数  
18.         return new FSA(rhs);  
19.     }  
20.     //...  
21. };  
22. #endif  

    客户端使用这个类时，就必须调用伪构造函数来创建对象。当然，由于对象是动态分配的，这时客户必须自己调用delete来删除对象。
    3、允许对象个数限制在某个给定的值： 使用前面在“模板与继承相结合的威力”中介绍的奇异递归模板模式技术，编写一个具有实例计数功能的基类即可，让需要计数的类继承这个类。因为类要实现计数功能，是一种“实现”的关系，故最好用私有继承，表示用这个基类来实现需要的功能。这里我们做一下修改，当需要计数的类对象个数超过上限时就抛出异常。注意不同的类可以通过特化这个基类的表示上限值的成员，以满足不同类对象个数的要求。

[cpp]  view plain copy

1. //objectcounter.hpp：对对象创建进行记数的模板  
2. #ifndef OBJECT_COUNTER_HPP  
3. #define OBJECT_COUNTER_HPP  
4. #include <cstddef>  
5. template<typename T>  
6. class ObjectCounter{ //用来记录T型对象构造的总个数  
7. private:  
8.     static std::size_t numObjects;//存在对象的个数  
9.     static const std::size_t maxObjects; //对象个数的上限，由需要计数的类来指定  
10.     void incr(){  
11.         if(ObjectCounter<T>::numObjects>=ObjectCounter<T>::maxObjects)  
12.             throw TooManyObjects();  
13.         ++ObjectCounter<T>::numObjects;  
14.     }  
15. protected:  
16.     ObjectCounter(){ //缺省构造函数  
17.         incr();  
18.     }  
19.     ObjectCounter(ObjectCounter<T> const& rhs){ //拷贝构造函数  
20.         incr();  
21.     }  
22.     ~ObjectCounter(){ //析构函数  
23.         --ObjectCounter<T>::numObjects;  
24.     }  
25. public:  
26.     class TooManyObjects{ }; //异常类  
27.     static std::size_t objectCount(){ //返回当前对象个数  
28.         return ObjectCounter<T>::numObjects;  
29.     }  
30. };   
31. //static成员变量必须在类外进行定义，由于是非const的，因此也要类外初始化  
32. template<typename T>    
33. std::size_t ObjectCounter<T>::numObjects=0;  
34. #endif  

 

[cpp]  view plain copy

1. //mystring.hpp：使用了对象计数的MyString类  
2. #ifndef MYSTRING_HPP  
3. #define MYSTRING_HPP  
4. #include "objectcounter.hpp"  
5. class MyString : private ObjectCounter<MyString>{  
6. public:  
7.     //由于是私有继承，要用using把objectCount函数变成公有  
8.     using ObjectCounter<MyString>::objectCount;  
9.     //...  
10. };  
11. //特化ObjectCounter的maxObjects成员，值为3，以限制MyString类对象的个数，  
12. //这个语句必须加入到MyString类的实现文件中  
13. template<>  
14. const std::size_t ObjectCounter<MyString>::maxObjects=3;  
15. #endif  

[cpp]  view plain copy

1. //countprinter.hpp：使用了对象计数的Printer类  
2. #ifndef PRINTER_HPP  
3. #define PRINTER_HPP  
4. #include "objectcounter.hpp"  
5. class Printer : private ObjectCounter<Printer>{  
6. public:  
7.     //由于是私有继承，要用using把objectCount函数变成公有  
8.     using ObjectCounter<Printer>::objectCount;  
9.     //...  
10. };  
11. //对Printer，对象个数特化为值4  
12. template<>  
13. const std::size_t ObjectCounter<Printer>::maxObjects=4;  
14. #endif  

[cpp]  view plain copy

1. //countertest.cpp：客户端代码，对对象计数进行测试  
2. #include <iostream>  
3. #include "mystring.hpp"  
4. #include "countprinter.hpp"  
5. int main(){  
6.     MyString s1,s2;  
7.     std::cout<<"number of MyString: "  
8.         <<MyString::objectCount()<<std::endl;  
9.     std::cout<<"number of MyString: "  
10.         <<s1.objectCount()<<std::endl;  
11.     s1.~MyString(); //减少一个对象  
12.     std::cout<<"number of MyString: "  
13.         <<MyString::objectCount()<<std::endl;  
14.     try{  
15.         MyString s3,s4,s5; //对象个数超过上限，会抛出出异常  
16.     }catch(ObjectCounter<MyString>::TooManyObjects& e){  
17.         std::cout<<"Too many MyString objects."<<std::endl;  
18.     }  
19.       
20.     Printer t1,t2,t3;  
21.     std::cout<<"number of Printer: "  
22.         <<Printer::objectCount()<<std::endl;  
23.     std::cout<<"number of Printer: "  
24.         <<t1.objectCount()<<std::endl;  
25.     Printer t4,t5; //对象个数超过上限，会抛出出异常，终止程序  
26.     return 0;  
27. }  

    这里ObjectCounter<T>模板用于计数，它需要作为基类，成员名的前面最好加类作用域符（也可用this->），使它变成依赖型名称。表示对象个数上限值的maxObjects成员是一个静态常量，它并没有初始化。我们必须在需要计数的类MyString、Printer中指定它的值。不同类的对象个数上限可能不同，因此我们只要特化maxObjects这个成员并指定需要的值即可（类模板可以只特化某个成员）。在MyString、Printer这些类中，由于是私有继承，因此要用using声明把objectCount函数变成公有，这样就可以用它来获取当前对象的个数。

=================================================================

我的C++实践(15)：判断对象是在堆上还是在栈上

转自 http://blog.csdn.net/zhoudaxia/article/details/4560338

    1、要求对象分配在堆上： 栈上对象在定义时自动构造，在生存期结束时自动析构。因此可把析构函数声明为私有，这样栈上对象离开作用域时就会出错，不能自动析构。同时为了在堆上能够正确的创建和删除对象，提供一个伪析构函数来访问真正的析构函数。客户端使用时需要调用伪析构函数来销毁堆上的对象。
    例如，对于一个表示无限精度数字的类，要让对象只能创建在堆上，如下：

[cpp]  view plain copy

1. //upnumber1.hpp：表示无限精度数字的类，其对象只能创建在堆上  
2. #ifndef UPNUMBER_HPP  
3. #define UPNUMBER_HPP  
4. class UPNumber{  
5. public:  
6.     UPNumber(){  
7.         //...  
8.     }  
9.     UPNumber(int val){  
10.         //...  
11.     }  
12.     UPNumber(double val){  
13.         //...  
14.     }  
15.     UPNumber(UPNumber const& rhs){  
16.         //...  
17.     }  
18.     void destroy() const{ //伪析构函数  
19.         delete this;  
20.     }  
21.     //...  
22. private:  
23.     ~UPNumber(); //析构函数私有  
24. };  
25. #endif  

[cpp]  view plain copy

1. //upnumber1test.cpp：对UPNumber，测试对象是否只能创建在堆上  
2. #include "upnumber1.hpp"  
3. int main(){  
4.     UPNumber *p=new UPNumber;  
5.     p->destroy(); //调用伪析构函数，不用直接用delete p;  
6.       
7.     UPNumber n; //会报错，析构函数为私有，编译器不能创建栈对象（否则不能销毁）  
8.     return 0;  
9. }  

    注意，析构函数声明为私有的类不能被继承，也不能被其他类包含。我们可以放宽一点，把析构函数声明为protected的，这样就可以被继承，包含这个类的其他类可以通过包含这个类对象的指针，而不是对象来达到组合的目的。
    2、判断对象是否在堆上： 堆上的对象肯定通过new调用了operator new，而栈上的对象则没有调用它。因此可以给类增加一个标志变量flag来判断是否调用了operator new，类需要重写operator new来设置这个flag。同时增加一个公有的布尔变量onTheHeap以让客户端判断对象是否在堆上。在所有的构造函数中都需要根据flag是否被设置来初始化onTheHeap的值。
    对上面的UPNumber类，可做如下的设计：

[cpp]  view plain copy

1. //upnumber2.hpp：表示无限精度数字的类，可判断单个的对象或整个数组内存是否在堆上  
2. #ifndef UPNUMBER_HPP  
3. #define UPNUMBER_HPP  
4. #include <cstddef>  
5. #include <new>  
6. class UPNumber{  
7. private:  
8.     static bool flag;  
9.     void initHeapFlag(){  
10.         if(!flag){ //如果没有调用operator new和operator new[]  
11.             onTheHeap=false; //说明是栈对象  
12.         }else{  
13.             onTheHeap=true; //否则调用了operator new或operator new[]，是堆对象  
14.             flag=false; //重置标志位  
15.         }  
16.     }  
17. public:  
18.     bool onTheHeap;  
19.     static void* operator new(std::size_t size);  
20.     static void* operator new[](std::size_t size) throw(std::bad_alloc);  
21.     UPNumber(){  
22.         initHeapFlag(); //初始化onTheHeap标志  
23.         //...  
24.     }  
25.     UPNumber(int val){  
26.         initHeapFlag();  
27.         //...  
28.     }  
29.     UPNumber(double val){  
30.         initHeapFlag();  
31.         //...  
32.     }  
33.     UPNumber(UPNumber const& rhs){  
34.         initHeapFlag();  
35.         //...  
36.     }  
37.     //...  
38. };  
39. bool UPNumber::flag=false; //静态变量在类外仍然需要定义  
40. void* UPNumber::operator new(std::size_t size){  
41.     flag=true; //设计标志位为true  
42.     return ::operator new(size);  
43. }  
44. void* UPNumber::operator new[](std::size_t size) throw(std::bad_alloc){  
45.     flag=true;  
46.     return ::operator new[](size);  
47. }  
48. #endif  

[cpp]  view plain copy

1. //upnumber2test.cpp：对UPNumber的测试，判断对象是否在堆上  
2. #include "upnumber2.hpp"  
3. #include <iostream>  
4. int main(){  
5.     UPNumber a; //在栈上  
6.     std::cout<<a.onTheHeap<<std::endl;  
7.     UPNumber *b=new UPNumber(); //在堆上  
8.     std::cout<<b->onTheHeap<<std::endl;  
9.     delete b;  
10.     UPNumber *num=new UPNumber[10]; //在堆上  
11.     std::cout<<num->onTheHeap<<std::endl; //相当于输出数组第1个元素是否在堆上  
12.     std::cout<<"The UPNumber array's heap flag: "<<std::endl;  
13.     for(int i=0;i<10;++i){  
14.         //只有第1个对象会输出1表示在堆上，其余都会输出0，但实际上  
15.         //它们是在堆上的  
16.         std::cout<<num[i].onTheHeap<<std::endl;  
17.     }  
18.     return 0;  
19. }  

    解释：
    （1）这样的设计只能判断单个的对象是否在堆上。我们还重写了operator new[]，这使得它可以判断整个数组所占的内存是否在堆上，但它却不能判断数组中的每个对象是否在堆上。从测试代码的运行结果就可以看出，对堆上的数组中的每个对象，只有第1个输出为1（即true），其余全部输出为0（即false），但我们知道实际上各个对象都在堆上的。这是因为创建整个数组时，operator new[]只会被调用一次，然后调用10次构造函数来初始化数组中的各个对象。当第1次调用构造函数时，onTheHeap被设为true，然后flag重置为false。后面的构造函数调用由于不会再调用operator new[]了，所以都会把onTheHeap设为false。
    （2）事实上，如果要实现在任何情况下都能判断对象是否在堆上，在C++中很难存在一种完全可移植的方案。比如，很多系统上，程序的地址空间都是按线性的顺序排列，栈从地址空间的高端往下增长，堆则从低端往上增长。这就可能通过把对象的地址（通过取址运算符&获得）与栈上的一个变量地址进行比较，若比栈变量地址小，则说明对象肯定在堆上。但并不是所有的系统都这样组织内存，而且很多系统的程序静态存储区会放在堆以下的地址空间中，这样就无法判断静态的栈对象了。这就是一种不可移植的方案，它依赖于系统的底层实现。一般UPNumber类中的实现基本能满足我们要求。因为只要通过第1个对象判断出了整个数组块是分配在堆上的，就自然知道了数组中的每个对象都是在堆上的（虽然它们的判断输出结果有出入）。
    （3）按照设计惯例，重写operator new和operator new[]，也要重写operator delete和operator delete[]，以保持对称。但这里我们只是设置了一下标志，并没有做其他定制性的工作，因此不对称也没关系。另一方面，要注意类的这些成员new和delete函数默认为static的，因为它们在构造对象之前或撤销对象之后运行，没有非静态的成员数据可操纵。
    我们可以把堆判断的功能抽离出来，设计成一个基类。为了使设计更完善，我们直接用一个列表来保存堆上的对象的地址，在重写的operator new中把分配的对象堆内存指针压入列表中。在重写的opeator delete中只要搜索这个列表，看看列表中有没有它的内存指针，有就说明是一个堆对象，需要释放内存，没有就说明是一个栈对象。

[cpp]  view plain copy

1. //heaptracked.hpp：HeapTracked类可判断单个的对象是否的在堆上  
2. #ifndef HEAP_TRACKED_HPP  
3. #define HEAP_TRACKED_HPP  
4. #include <cstddef>  
5. #include <list>  
6. class HeapTracked{  
7. private:  
8.     static std::list<const void*> addresses; //存放各个堆对象的指针  
9. public:  
10.     class MissingAddress{ }; //异常类  
11.     virtual ~HeapTracked()=0; //纯虚函数  
12.     static void* operator new(std::size_t size);  
13.     static void operator delete(void *ptr);  
14.     bool isOnHeap() const;  
15. };  
16. std::list<const void*> HeapTracked::addresses; //静态对象在类外仍需定义  
17. HeapTracked::~HeapTracked(){ //纯虚的析构函数必须要有再定义  
18. }  
19. void* HeapTracked::operator new(std::size_t size){  
20.     void *memPtr=::operator new(size); //分配内存  
21.     addresses.push_front(memPtr); //把地址压入列表前端  
22.     return memPtr;  
23. }  
24. void HeapTracked::operator delete(void *ptr){  
25.     if(ptr==0) return;  
26.     //在列表中查找是否有这个指针  
27.     std::list<const void*>::iterator it=  
28.         find(addresses.begin(),addresses.end(),ptr);  
29.     if(it!=addresses.end()){ //若找到，说明指针指向了堆上的内存  
30.         addresses.erase(it); //从列表中移除这个指针  
31.         ::operator delete(ptr); //释放指针指向的内存  
32.     }else{ //否则ptr不是一个堆对象的指针，不能调用operator delete，抛出异常  
33.         throw MissingAddress();  
34.     }  
35. }  
36. bool HeapTracked::isOnHeap() const{  
37.     //获取*this对象的真正内存起始地址  
38.     const void* rawAddress=dynamic_cast<const void*>(this);  
39.     //在列表中查找this指针  
40.     std::list<const void*>::iterator it=  
41.         find(addresses.begin(),addresses.end(),rawAddress);  
42.     return it!=addresses.end();  
43. }  
44. #endif  

[cpp]  view plain copy

1. //heaptrackedtest.cpp：对堆跟踪器HeapTracked类的测试  
2. #include <iostream>  
3. #include "heaptracked.hpp"  
4. class Asset : public HeapTracked{  
5. private:  
6.     int value;  
7. public:  
8.     //...  
9. };  
10. int main(){  
11.     Asset a;  
12.     std::cout<<a.isOnHeap()<<std::endl; //不在堆上  
13.     Asset *b=new Asset;  
14.     std::cout<<b->isOnHeap()<<std::endl; //在堆上  
15.     delete b;  
16.     return 0;  
17. }  

    HeapTracked是抽象混合基类，因为它有纯虚函数，因此是抽象基类，不能被实例化，只能被继承，由子类来创建对象。它的很多非虚的成员函数有功能实现，因此又是一般的基类，这些功能代表了各个子类的共性，因此把它称为抽象混合基类。注意当把析构函数声明为纯虚的时，必须同时要有定义，因为子类一定会调用基类的析构函数，这样它就必须有定义，而不只是声明。在使用时，让需要堆判断功能的类直接继承HeapTracked类即可。注意这个类只能判断单个对象是否在堆上，不能判断数组是否在堆上，当然可以通过重写operator new[]来完善。唯一需要解释的就是那个dynamic_cast，它把this指针转换成const void*。因为由多继承或虚基类继承而来的对象会有多个地址，因此我们必须要把一个指针dynamic_cast成void*类型，这就会使它指向对象的真正内存开始处。
    3、禁止对象分配在堆上： 这个比较容易。把operator new/operator delete、operator new[]/operator delete[]都声明为私有即可。注意这样的类不能作为基类，也不能被其他类包含。

====================================================================================================================