將N層集合對象自動轉化為對應的.NET泛型對象(C++)

昨天別人碰到的問題，晚上回來想了一下給出了一個用模板進行類型推導的解決方案。

問題本身需求很清楚，就是需要寫一個Util函數，將C++裡面的那些模板(template)集合對象自動轉換成.NET裡面的泛型(Generic)集合對象，比如將vector<int>轉化成List<int>^。因為類型(Type)不定，所以用模板來進行轉化是不二的選擇。問題的痛點在於這些集合類還可以是巢狀型別，也就是說集合裡面裝的還是集合(比如將vector<vector<int> >轉化成List<List<int>^>^)，甚至還得考慮多層集合嵌套的情況。

1. // NativeToManagedTypeApp.cpp : main project file.
2. // author: Anders Deng
3. // date: 2008/8/29
5. #include "stdafx.h"
6. #include <vector>
8. using namespace System;
9. using namespace System::Collections::Generic;
10. using namespace std;
12. // for method overload 
13. struct __true__value {};
14. struct __false__value{};
16. // some classes for type traits
17. template<class T>
18. struct collection_Type_Traits
19. {
20.     typedef __false__value isCollection;
21.     typedef T __template__param__type;
22. };
24. template<typename T>
25. struct collection_Type_Traits<std::vector<T> >
26. {
27.     typedef __true__value isCollection;
28.     typedef T __template__param__type;
29. };
31. template<class T>
32. struct collection_Type_Traits<List<T>^ >
33. {
34.     typedef __true__value isCollection;
35.     typedef T __template__param__type;
36. };
38. // add more specialization template definition
39. // ... 
40. template<class T>
41. struct managed_Type_Traits
42. {
43.     typedef __false__value isValueType;
44.     typedef T param_type_name;
45. };
47. template<class T>
48. struct managed_Type_Traits<T^>
49. {
50.     typedef __false__value isValueType;
51.     typedef T param_type_name; // remove ^ from reference type
52. };
54. template<>
55. struct managed_Type_Traits<int>
56. {
57.     typedef __true__value isValueType;
58.     typedef int param_type_name;
59. };
61. // add more specialization template definition for other required value class
62. // ...
64. public ref class Util
65. {
66. public:
67.     template<class NativeType, class ManagedType>
68.     static ManagedType nativeToManaged(NativeType nativeObj)
69.     {
70.         return __nativeToManaged<NativeType, ManagedType>(nativeObj, collection_Type_Traits<NativeType>::isCollection(), managed_Type_Traits<ManagedType>::isValueType());
71.     }
73. private:
74.     // collection && reference type
75.     template<class NativeType, class ManagedType>
76.     static ManagedType __nativeToManaged(NativeType nativeObj, __true__value, __false__value)
77.     {
78.         ManagedType list = gcnew managed_Type_Traits<ManagedType>::param_type_name();
79.         for (NativeType::iterator it = nativeObj.begin(); it != nativeObj.end(); ++it)
80.         {
81.             typedef collection_Type_Traits<NativeType>::__template__param__type InternalNativeType;
82.             typedef collection_Type_Traits<ManagedType>::__template__param__type InternalManagedType;
84.             list->Add(__nativeToManaged<InternalNativeType, InternalManagedType>(*it, collection_Type_Traits<InternalNativeType>::isCollection(), managed_Type_Traits<InternalManagedType>::isValueType()));
85.         }
87.         return list;
88.     }
90.     // non-collection && reference type
91.     template<class NativeType, class ManagedType>
92.     static ManagedType __nativeToManaged(NativeType nativeObj, __false__value, __false__value)
93.     {
94.         return gcnew managed_Type_Traits<ManagedType>::param_type_name(nativeObj.c_str());
95.     }
97.     // non-collection && reference type
98.     template<class NativeType, class ManagedType>
99.     static ManagedType __nativeToManaged(NativeType nativeObj, __false__value, __true__value)
100.     {
101.         return nativeObj;
102.     }
103. };
105. int main(array<System::String ^> ^args)
106. {
107.     // ----------------------------------
108.     // test vector<int> => List<int>^
109.     // ----------------------------------
110.     vector<int> intV;
111.     intV.push_back(4);
112.     intV.push_back(5);
113.     List<int>^ l = Util::nativeToManaged<vector<int>, List<int>^>(intV);
115.     for each(int i in l)
116.     {
117.         Console::Write("{0} ", i);
118.     }
119.     Console::WriteLine();
121.     // ----------------------------------
122.     // test vector<vector<int>> => List<List<int>^>^
123.     // ----------------------------------
125.     vector<vector<int>> iVV;
126.     vector<int> iV;
127.     iV.push_back(1);
128.     iV.push_back(2);
129.     iVV.push_back(iV);
131.     List<List<int>^ >^ list = Util::nativeToManaged<vector<vector<int> >, List<List<int>^>^ >(iVV);
133.     for each(List<int>^ l in list)
134.     {
135.         for each(int i in l)
136.             Console::Write("{0} ", i);
137.         Console::WriteLine();
138.     }
140.     // ---------------------------------
141.     // test vector<vector<string>> => List<List<String^>^>^
142.     // ---------------------------------
143.     vector<string> sV;
144.     vector<vector<string>> sVV;
145.     sV.push_back("abc");
146.     sV.push_back("def");
147.     sV.push_back("ghi");
148.     sVV.push_back(sV);
150.     List<List<String^>^>^ sll = Util::nativeToManaged<vector<vector<std::string>>, List<List<String^>^>^>(sVV);
152.     for each(List<String^>^ sl in sll)
153.     {
154.         for each(String^ s in sl)
155.             Console::Write("{0} ", s);
156.         Console::WriteLine();
157.     }
159.     return 0;
160. }

代碼如上，就不多解釋了。關於type traits可以參考這篇文章，關於特化(specialization)、偏特化(partial specialization)的文章可以看侯捷先生的《STL源碼分析》。需要特別指出的是，雖然.NET的Generic原理上不支援特化和偏特化的用法(因為.NET泛型是運行時機制，考慮到.NET極強的meta data，個人覺得確實也不必要)，但是C++/CLI使用的時候仍然可以利用模板來進行特化/偏特化處理。比如上面代碼中的managed_Type_Traits<T^>類型就是用來提取不帶^符號的原始類型，這樣就可以讓模板自動產生出gcnew T(...)這樣的代碼了。Anyway，C++的模板就跟宏(Macro)一樣，就看你怎麼運用其產生需要的代碼了。

記得n年前學C++的時候看過不少講模板特化，偏特化的資料，讀STL、boost等Library原始碼的時候也發現裡面將模板元編程(TMP)的思想發揮的淋漓盡致。不過慚愧的是自己真正coding的時候還沒直接用過，這次算是親自試了一把，功能還是很強大的(當然請不要拿來與諸如Ruby這樣的動態語言比，畢竟they are totally different)。

 

小結：玩TMP實際上就是與編譯器鬥，其樂無窮:)