Automatically converts N-layer collection objects to corresponding. Net generic objects (C ++)

When someone encountered a problem yesterday, I came back at night and thought about a solution to type deduction using templates.

The problem itself needs to be clear, that is, you need to write an util function to automatically convert the template set objects in C ++.. Net (for example, convert vector <int> to list <int> ^. Because the type is not fixed, it is the best choice to use a template for conversion. The difficulty is that these collection classes can also be nested types, that is to say, the set is still installed in the Set (for example, converting the vector <int> to list <int> ^), and even the nested multi-layer set needs to be considered.

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, role <internalnativetype >:: iscollection (), role <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 <int >=> 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 <int>, 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 <string >=> 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 <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. }

The code above will not be explained much. For more information about type traits, see this article. For more information about specialization and partial specialization, see Mr Hou Jie's STL source code analysis. In particular, though. net generic principle does not support the use of special and biased (because. net generic is the runtime mechanism, considering. net strong meta data, I personally think it is not necessary), but the C ++/CLI can still use templates for special/partial special processing. For example, the managed_type_traits <t ^> type in the above code is used to extract the original type without the ^ symbol, so that the template can automatically generate gcnew T (...) this is the code. The anyway and C ++ templates are the same as those of macro (macro), depending on how you use them to generate the required code.

I remember reading a lot of special and special templates when I learned C ++ N years ago. When I read the source code of libraries such as STL and boost, I also found that the template metadata programming (TMP) the idea is fully realized. But I am ashamed that I haven't used coding before. I tried it myself this time, the function is still very powerful (please do not compare it with dynamic languages such as Ruby, after all they are totally different ).

 

Conclusion: Playing TMP is actually a battle with the compiler. It's fun :)