C++ 下 typeof auto

现在我们有这样一坨代码：

[cpp] view plaincopy

1. std::vector<int> arr;  
2. // ...  
3. for(std::vector<int>::iterator iter = arr.begin(); iter != arr.end(); ++iter)  
4. {  
5.     // ...  
6. }  

其中难看而又不好维护的std::vector::iterator，由于我们无法自动获知arr.begin()的类型，从而不得不一写再写。

C++11下有typeof和auto关键字，于是像上面第3行那样纠结的位置可以变得简单不少：

[cpp] view plaincopy

1. std::vector<int> arr;  
2. // ...  
3. for(auto iter = arr.begin(); iter != arr.end(); ++iter)  
4. {  
5.     // ...  
6. }  

在vc下（2005、2008、2010）对这两个关键字都不支持；gcc（4.7以前）支持typeof，但是没有auto。

假如有typeof的话，auto可以很简单的模拟出来，那么问题的关键点在于如何实现typeof。

---

一、需要注册id的typeof

在C++里，可以在编译期计算表达式类型的只有下面两个东西：

1. sizeof
    这东西很强大，不论后面的表达式是什么，均可以在编译期正确得到类型并直接返回类型大小。
2. typeid
    若不使用C++的RTTI功能，typeid会在编译期计算出表达式的类型，并返回一个type_info引用。

使用第一种方法，我们可以得到一个数字，只要这个数字对类型而言是唯一的，那么我们就可以通过它反向得到类型。
类似这样写：

[cpp] view plaincopy

1. template <typename T>  
2. struct Type2ID;  
3. template <int id>  
4. struct ID2Type;  
5.   
6. template <typename T>  
7. Type2ID<T> encode(const T&);  
8. template <typename T>  
9. Type2ID<T> encode(T&);  
10.   
11. #define type_of(...) \  
12.     ID2Type<sizeof(encode((__VA_ARGS__)))>::type_t  

之所以用可变参数宏，是考虑到需要能够支持传入如逗号表达式等带逗号的参数。

第6-9行定义了假函数encode，负责把__VA_ARGS__的类型取出来。sizeof运算符保证了encode并不会真正被执行到。

为了让我们前面的代码可以工作，还需要使用模板特化的机制注册一些类型：

[cpp] view plaincopy

1. #define REGISTER_TYPE(type, n) \  
2.     template <> \  
3.     struct Type2ID<type> { char id[n]; }; \  
4.     template <> \  
5.     struct ID2Type<n>    { typedef type type_t; };  
6.   
7. REGISTER_TYPE(int,    1)  
8. REGISTER_TYPE(long,   2)  
9. REGISTER_TYPE(char,   3)  
10. REGISTER_TYPE(double, 4)  

现在我们可以支持int、long、char和double表达式的动态类型推导了。

---

二、自动分配id的typeof

目前我们实现的type_of虽然可以工作，但在干活之前必须要先注册一大堆类型，而且还需要给每个类型分配一个唯一的id。没有注册的类型是无法动态推导的。
boost里使用了mpl库里的一些东西，完成了REGISTER_TYPE的过程，自动化的给每个放入BOOST_TYPE_OF里的类型分配了唯一的id。我们手头上没有这么NX的东西，只好使用一些轻量级的玩意了。

比如上面提到的typeid，就是个不错的id生成器，也具有sizeof类似的功能。
虽然多态类继承的情况会让typeid在编译期失效，但只限于传入对象的情况。我们可以使用指针规避这个问题，typeid将在编译期返回一个指针类型的type_info。

下面我们开始实作可以自动分配id的typeof。首先，我们需要一个可以把type_info&变成类型的玩意：

[cpp] view plaincopy

1. template <const std::type_info& type_id>  
2. struct TypeID {};  
3.   
4. #define type_id(...) TypeID<typeid(__VA_ARGS__)>  

然后是从TypeID中把type取出来的类模板：

[cpp] view plaincopy

1. /* 
2.     Extract a type from TypeID 
3. */  
4.   
5. template<typename ID>  
6. struct Extract;  
7.   
8. #define type_extract(...) \  
9.     Extract<type_id(__VA_ARGS__) >::type_t  

把类型编码成待注册的类型：

[cpp] view plaincopy

1. /* 
2.     Encode a expression 
3. */  
4.   
5. template <typename T>  
6. struct Encode { typedef T* type_t; };  
7.   
8. template <typename T>  
9. typename Encode<T>::type_t encode(const T&);  
10. template <typename T>  
11. typename Encode<T>::type_t encode(T&);  

这里使用了和先前同样的encode假函数技巧，同时通过Encode把一个类型变成一个类型指针。

最后把类型解出来：

[cpp] view plaincopy

1. /* 
2.     Decode a type 
3. */  
4.   
5. template <typename T>  
6. struct Decode;  
7. template <typename T>  
8. struct Decode<T*> { typedef T type_t; };  
9.   
10. #define type_of(...) \  
11.     Decode<type_extract(encode((__VA_ARGS__)))>::type_t  

这里使用Decode把Encode变化了的类型变回来。

使用Encode、Decode的目的，是为了绕过typeid对对象可能进行的运行时处理。

不要妄想C++的模板自动推导可以这样写：

[cpp] view plaincopy

1. template<typename T>  
2. struct Extract<TypeID<typeid(T*)> >  
3. {  
4.     typedef T* type_t;  
5. };  

编译器会无情的告诉我们一个error发生了。假如可以这样自动推导，那我们接下来会省很多力气。

为了让Extract能够认得传入的类型信息，我们得注册我们的类型，但是不再需要传入id了：

[cpp] view plaincopy

1. #define REGISTER_TYPE(type) \  
2.     template<> \  
3.     struct Extract<type_id(type*) > { typedef type* type_t; };  
4.   
5. REGISTER_TYPE(int)  
6. REGISTER_TYPE(long)  
7. REGISTER_TYPE(char)  
8. REGISTER_TYPE(double)  

可以测试一下，typeid是否能完成编译期的类型自动推导。为了说明问题，代码使用了多态的对象来测试效果：

[cpp] view plaincopy

1. class A  
2. {  
3. public:  
4.     virtual void func() { std::cout << "A" << std::endl; }  
5. };  
6. REGISTER_TYPE(A)  
7.   
8. class B : public A  
9. {  
10. public:  
11.     virtual void func() { std::cout << "B" << std::endl; }  
12. };  
13. REGISTER_TYPE(B)  
14.   
15. int main()  
16. {  
17.     B bb;  
18.     A& aa = bb;  
19.     type_of(aa) cc;  
20.     cc.func();  
21.   
22.     return 0;  
23. }  

在vc编译器（2005、2008、2010、2012）下编译后，我们会顺利的得到一个喜闻见乐的“A”。

---

三、全自动的typeof

虽然仅仅写一行REGISTER_TYPE已经不是什么大问题了，但多写这一行还是一个让人不爽的事情。
想要实现全自动注册，得解决一个麻烦的问题：如何通过const type_info&特化模板？

幸好vc里还有一些小花招可以利用，我们可以尝试在一个类的内部特化一个类模板：

[cpp] view plaincopy

1. /* 
2.     Extract a type from TypeID 
3. */  
4.   
5. struct empty_t {};  
6.   
7. template<typename ID, typename T = empty_t>  
8. struct Extract;  
9.   
10. template<typename ID>  
11. struct Extract<ID, empty_t>  
12. {  
13.     template <bool>  
14.     struct id2type;  
15. };  
16.   
17. template<typename ID, typename T>  
18. struct Extract : Extract<ID, empty_t>  
19. {  
20.     template <>  
21.     struct id2type<true> { typedef T type_t; };  
22. };  
23.   
24. #define type_extract(...) \  
25.     Extract<type_id(__VA_ARGS__) >::id2type<true>::type_t  

这个花招的“精髓”在于，类模板的内部又有一个类模板，并且使用继承让“特化在特化中生效”。这种玩法在gcc中是编译不过的，它会抱怨你正在试图特化一个位于非全局且非namespace区域的类模板。不过不要紧，只要vc能用就可以了。

这样我们就可以写出一个专门用于注册的类模板：

[cpp] view plaincopy

1. /* 
2.     Register a type 
3. */  
4.   
5. template<typename T, typename ID>  
6. struct Register : Extract<ID, T>  
7. {  
8.     typedef typename id2type<true>::type_t type_t;  
9. };  

它将通过继承的Extract自动特化出一个存有类型信息的id2type。

后面的事情就简单了，只需要稍微改写一下Encode：

[cpp] view plaincopy

1. template <typename T>  
2. struct Encode  
3. {  
4.     typedef T* enc_type_t;  
5.     typedef Register<enc_type_t, type_id(enc_type_t)> reg_type;  
6.     typedef typename reg_type::type_t type_t;  
7. };  

现在的type_of可以直接作用于任何表达式，并在编译时自动推导出类型了。

扫尾工作：

区别对待vc和gcc，并定义auto：

[cpp] view plaincopy

1. #ifdef __GNUC__  
2. #define type_of(...) __typeof((__VA_ARGS__))  
3. #else  
4. #define type_of(...) \  
5.     Decode<type_extract(encode((__VA_ARGS__)))>::type_t  
6. #endif  
7. #define auto(name, ...) type_of(__VA_ARGS__) name((__VA_ARGS__))  

必须要记得我们前面写的那些类模板也只能在vc下工作，需要一并放入#else段里。