发一个刷leetcode时突发奇想弄出来的玩意：仿python的variant变量。

Croper

一直用c++在刷leetcode，但leetcode上的测试数据都是python格式的，调试起来很不方便。
最先是想要弄一个翻译器，把python格式的测试数据翻译成c++ stl能支持的。。。然后越弄越奇怪，就弄出了这么一个玩意儿，算是仿冒python的变量类型把：

源代码发在楼下，先发个说明，算是文档吧- -

1. #include<vector>
   
2. #include "variant.h"  //include头文件
   
3. 
   
4. using namespace std;
   
5. using namespace croper;  //variant定义在croper命名空间下
   
6. int Test1(int, vector<string>);
   
7. void Swap(int& a, int& b);
   
8. 
   
9. 
   
10. int main() {
    
11.         cout << "================================================================================================" << endl;
    
12.         cout <<    "1、能接受并输出多种类型的变量，现在支持int，double，bool，string，以及vector 5种类型。"        << endl;
    
13.         cout << "================================================================================================" << endl;
    
14.         variant a = 5;                      //int
    
15.         variant b = 4.99;                   //double
    
16.         variant c = "hello world";                        //string
    
17.         variant d = false;                  //bool
    
18.         variant o;
    
19.         cout << a << endl;
    
20.         cout << b << endl;
    
21.         cout << c << endl;
    
22.         cout << d << endl;
    
23.         cout << o << endl;
    
24.         cout << "================================================================================================" << endl;
    
25.         cout << "    2、其中vector特化为python里的list类型，能容纳各种数据类型（其实就是vector<variant>)"          << endl;
    
26.         cout << "================================================================================================" << endl;
    
27.         variant e = { 5,4.99,false,"hello world" };            //同时容纳多种数据类型
    
28.         variant f = { {"there","is","no"},12315,"bigbang" }; //支持嵌套的初始化
    
29.         cout << e << endl;
    
30.         cout << f << endl;
    
31.         f.append(e);                  //可以继续添加元素
    
32.         e.append(f);                   //出现环路也可以正确识别
    
33.         cout << f << endl;
    
34. 
    
35.         cout << "================================================================================================" << endl;
    
36.         cout << "       3、可以使用字符串初始化（这其实是最初的目的)                                                                                     " << endl;
    
37.         cout << "================================================================================================" << endl;
    
38.         variant s1 = Variant_Read("5,Bob,false,[48,22,4.99],[4,5],[125,54]");   //使用字符串初始化
    
39.         variant s2 = "5,3,9,[48,22,4.99],[4,5],[125,54]"_V;               //更加简单的写法
    
40.         cout << s1 << endl;
    
41.         cout << s2 << endl;
    
42.        
    
43.         cout << "================================================================================================" << endl;
    
44.         cout << "       4、可以将自身展开并传递给特定函数：                                                                                                         " << endl;
    
45.         cout << "================================================================================================" << endl;
    
46.         variant r1 = R"(5,["Allice","Bob","Carol","Dave"])"_V;      
    
47.         int x = r1.call(Test1);          //将r1展开传递给test1
    
48.         cout << "返回值为" << x << endl;
    
49.         cout << endl;
    
50. 
    
51.         variant r2 = { 5,2 };
    
52.         cout << "调用前r2为" << r2 << endl;
    
53.         r2.call(Swap);                   //将r2展开传递给Swap,Swap将交换两个参数的值，这将正确反映到r2上
    
54.         cout << "调用后r2为" << r2 << endl;
    
55. 
    
56.         cout << "================================================================================================" << endl;
    
57.         cout << "       5、大部分运算符重载工作未完工，dict类型尚未完成，敬请期待                                                    " << endl;
    
58.         cout << "================================================================================================" << endl;
    
59.         system("pause");
    
60. }
    
61. 
    
62. int Test1(int n, vector<string> v) {
    
63.         int ret = 0;
    
64.         for (auto s : v) {
    
65.                 ret += s.size();
    
66.                 for (int i = 0; i < n; ++i) {
    
67.                         cout << s << endl;
    
68.                 }
    
69.                 cout << endl;
    
70.         }
    
71.         return ret;
    
72. }
    
73. void Swap(int& a, int& b) {
    
74.         int t = a;
    
75.         a = b;
    
76.         b = t;
    
77. }
    

复制代码

Croper

.h文件分为4部分

1、variant_meta.h

1. #ifndef __VARIANT_META_H
   
2. #define __VARIANT_META_H
   
3. //variant需要用到的某些元编程模块
   
4. 
   
5. 
   
6. //检测两个类型是否相同
   
7. template<typename T1, typename T2>
   
8. class IsSame {
   
9. private:
   
10.         enum { result = 0};
    
11. };
    
12. template<typename T>
    
13. class IsSame<T,T> {
    
14. private:
    
15. 
    
16.         enum { result = 1 };
    
17. };
    
18. 
    
19. //检测两个类型是否能互相转化
    
20. template<typename Dest, typename Orig>
    
21. class CanMatch{
    
22. private:
    
23.         static char Test(Dest);
    
24.         static int Test(...);
    
25.         static Orig MakeOrig();
    
26. public:
    
27. #pragma warning(disable:4244)
    
28.         enum { result = sizeof(Test(MakeOrig())) == sizeof(char) };
    
29. #pragma warning(default:4244)
    
30. };
    
31. 
    
32. 
    
33. //检测某个类型是否是引用
    
34. template<typename T>
    
35. struct isReference{
    
36.         enum { result = 0};
    
37. };
    
38. 
    
39. template<typename T>
    
40. struct isReference<T&> {
    
41.         enum { result = 1 };
    
42. };
    
43. 
    
44. template<typename T>
    
45. struct isReference<T&&> {
    
46.         enum { result = 1 };
    
47. };
    
48. 
    
49. #define IF_0(Code)
    
50. #define IF_1(Code) Code
    
51. #define IF(Bool,Code) IF_##Bool##(Code)
    
52. 
    
53. #endif

复制代码

Croper

variant_sruct.h

1. //=======================================================================================
   
2. //--------------------------------------------------------------------------------------|
   
3. //                          variant类的框架，不含Data部分                                                                |       
   
4. //--------------------------------------------------------------------------------------|
   
5. //=======================================================================================
   
6. #ifndef __VARIANT_STRUCT_H
   
7. #define __VARIANT_STRUCT_H
   
8. 
   
9. #include <share.h>
   
10. #include <iostream>
    
11. #include <initializer_list>
    
12. #include <string>
    
13. #include <vector>
    
14. #include <assert.h>
    
15. #include "variant_meta.h"
    
16. 
    
17. namespace croper {
    
18. 
    
19. //================================================================================
    
20. //定义开始
    
21. //===============================================================================
    
22.         class variant {
    
23.         private:
    
24.                 using string = std::string;
    
25.         public:
    
26.                 using list = std::vector<variant>;
    
27.                 static const variant None;
    
28. #ifndef VARIANT_REGISTER_TYPE
    
29. #define VARIANT_REGISTER_TYPE
    
30. #endif
    
31. //****************************************************************************
    
32. 
    
33. 
    
34. //==================================================================================
    
35. //IData类，定义Data的接口
    
36. //==================================================================================
    
37.                 struct IData {
    
38.                 public:
    
39.                         //自身的类型
    
40.                         virtual std::string mytype() const = 0;
    
41.                         //转化为字符串，对于于__str__方法
    
42.                         virtual std::string to_string() const = 0;
    
43.                         //返回自身的拷贝
    
44.                         virtual IData* copy() const = 0;
    
45.                         //以类型T获取数据，会发生类型的默认转化，当类型不匹配时会给出默认值,如果定义了宏VARIANT_STRICT_TYPE_CHECK的话会报错
    
46.                         template <typename T> T get_data();
    
47.                         //以类型T获取数据，会发生类型的默认转化
    
48.                         template <typename T> void trans_type(variant*);
    
49.                         //原始数据：类型指定错误会错误
    
50.                         template <typename T> T& original_data();
    
51. 
    
52. 
    
53.                         //*******************************宏代码块***************************************
    
54.                                         //get_data与astype是模板，本身无法继承，这里让get_data调用_get_data_int,_get_data_float等以实现继承
    
55. #define VARIANT_REGISTER(T) \
    
56.                         virtual T _get_data_##T##() = 0;\
    
57.                         virtual void _trans_type_##T##(variant*) = 0;\
    
58.                         template<> T get_data<T>(){\
    
59.                                 return _get_data_##T##();\
    
60.                         }\
    
61.                         template<> void trans_type<T>(variant* base) {\
    
62.                                 _trans_type_##T##(base);\
    
63.                         }
    
64.                         VARIANT_REGISTER_TYPE;
    
65. #undef VARIANT_REGISTER
    
66.                         //****************************************************************************
    
67.                 };
    
68.                 //声明为友元
    
69.                 friend struct IData;
    
70.                 //创建Data，解耦合用
    
71.                 template <typename T>
    
72.                 static std::shared_ptr<IData> CreateData();
    
73.                 template <typename T>
    
74.                 static std::shared_ptr<IData> CreateData(const T& t);
    
75. 
    
76. //========================================================================================
    
77. //Judge类，技术类，根据不同的模板参数给出不同的函数                                                                       
    
78. //========================================================================================
    
79.                 template <int N, typename T, typename my_type, typename templ_arg>
    
80.                 struct Judge;
    
81.                 //Judge<0>
    
82.                 template <typename T, typename my_type, typename templ_arg>
    
83.                 struct Judge<0, T, my_type, templ_arg> {
    
84.                         static T get_data(my_type*);
    
85.                         static void transtype(my_type*, variant*);
    
86.                 };
    
87.                 //Judge<1>
    
88.                 template <typename T, typename my_type, typename templ_arg>
    
89.                 struct Judge<1, T, my_type, templ_arg> {
    
90.                         static T get_data(my_type* self);
    
91.                         static void transtype(my_type*, variant*);
    
92.                 };
    
93. 
    
94.                 //Judge<2>
    
95.                 template <typename T, typename my_type, typename templ_arg>
    
96.                 struct Judge<2, T, my_type, templ_arg> {
    
97.                         static void transtype(my_type*, variant*);
    
98.                 };
    
99. 
    
100.                 //Judge<3>
     
101.                 template <typename T, typename my_type, typename templ_arg>
     
102.                 struct Judge<3, T, my_type, templ_arg> {
     
103.                         static void transtype(my_type*, variant*);
     
104.                 };
     
105. 
     
106.                 //Judge<4>
     
107.                 template <typename T, typename my_type, typename templ_arg>
     
108.                 struct Judge<4, T, my_type, templ_arg> {
     
109.                         static void transtype(my_type*, variant*);
     
110.                 };
     
111.                 //========================================================================================
     
112.                 //DistinguishType类，技术类，当两type相同时返回0，第一个是list时返回1，第二个是list时返回2，能转化时返回3，不能转化时返回4                                                               
     
113.                 //========================================================================================
     
114.         public:
     
115.                 template <typename Dest, typename Orig>
     
116.                 struct DistinguishType {
     
117.                 public:
     
118.                         enum { result = 4 - CanMatch<Dest, Orig>::result };
     
119.                 };
     
120.                 template <typename T>
     
121.                 struct DistinguishType<T, T> {
     
122.                         enum { result = 0 };
     
123.                 };
     
124.                 template <typename T>
     
125.                 struct DistinguishType<list, T> {
     
126.                         enum { result = 1 };
     
127.                 };
     
128.                 template <typename T>
     
129.                 struct DistinguishType<T, list> {
     
130.                         enum { result = 2 };
     
131.                 };
     
132.                 template <>
     
133.                 struct DistinguishType<list, list> {
     
134.                         enum { result = 0 };
     
135.                 };
     
136.                 //========================================================================================
     
137.                 //_IData_templ类，技术类
     
138.                 //模板分离后的IData，使分离的_get_data_int,_get_data_double等都指向同一个get_data,并使用Judge判断其类型是否匹配，
     
139.                 //不匹配时，其将指向一个报错的函数
     
140.                 //如果使用if语句会导致虽然这一块永远不会执行但是无法通过编译。
     
141.                 //========================================================================================
     
142. 
     
143.                 template <typename templ_arg>
     
144.                 struct _IData_templ :public IData {
     
145.                         virtual templ_arg& get_data() = 0;
     
146.                         //*******************************宏代码块***************************************
     
147. #define VARIANT_REGISTER(T) \
     
148.                         virtual T _get_data_##T##() override{\
     
149.                                 return Judge<CanMatch<T,templ_arg>::result,T,_IData_templ,templ_arg>::get_data(this);\
     
150.                         }\
     
151.                         virtual void _trans_type_##T##(variant* base) override{\
     
152.                                 constexpr int d=DistinguishType<T,templ_arg>::result;\
     
153.                                 Judge<d, T, _IData_templ, templ_arg>::transtype(this,base);\
     
154.                         }
     
155.                         VARIANT_REGISTER_TYPE;
     
156. #undef VARIANT_REGISTER
     
157.                         //****************************************************************************
     
158.                 };
     
159.                 //=====================================================================
     
160.                 //variant类自身的函数
     
161.                 //=====================================================================
     
162.         private:
     
163.                 //使用智能指针指向_data,这样不再需要对_data进行内存管理，且能进行浅拷贝。
     
164.                 //python变量也是相似的机制
     
165.                 std::shared_ptr<IData> _data;
     
166.                 //====================================================================
     
167. 
     
168.         public:
     
169.                 //构造函数
     
170.                 variant();
     
171.                 //根据原始数据构造
     
172.                 template <typename T> variant(const T& t);
     
173.                 //根据多个原始数据构造出列表
     
174.                 variant(const std::initializer_list<variant>&);
     
175.                 template <typename ...T> variant(const T&... t);
     
176.                 //复制构造函数,不需要，直接浅复制即可
     
177.                 variant(const variant&) = default;
     
178.                 //析构函数,不需要
     
179.                 ~variant() = default;
     
180. 
     
181.                 //以字符串形式输出Data的类型
     
182.                 std::string type() const;
     
183.                 //Data是否是某种特定类型
     
184.                 template <typename T>bool is_type() const;
     
185.                 //将Data转化为某种特定类型，如果不兼容会转化为空值
     
186.                 template <typename T>variant& set_type();
     
187.                 //将自身重置为None
     
188.                 void clear();
     
189.                 //转化为字符串：
     
190.                 std::string to_string() const;
     
191.                 //将自身解包为参数传入function
     
192.                 template <typename retT, typename ...TArgs> retT call(retT(*fp)(TArgs...));
     
193.                 //将自身解包为参数传入function,返回值为void的重载版本
     
194.                 template <typename ...TArgs> void call(void(*fp)(TArgs...));
     
195. 
     
196.                 //当自身为list时于尾部插入一个元素。
     
197.                 void append(const variant&);
     
198.                 //当自身为list时获得list的大小
     
199.                 size_t size() const;
     
200.                 //当自身为list时返回尾部元素
     
201.                 variant& back();
     
202. 
     
203.                 //赋值函数
     
204.                 template <typename T> variant& operator=(const T&);
     
205.                 //赋值函数，std::vector重载版本
     
206.                 template <typename T> variant& operator=(const std::vector<T>&);
     
207.                 //赋值函数，const char*重载版本，以接受字面常量
     
208.                 variant& operator=(const char* sz);
     
209.                 //复制构造函数，不需要重写
     
210.                 variant& operator=(const variant& v) = default;
     
211. 
     
212. 
     
213.                 //转化为特定类型
     
214.                 template <typename T> operator T() const;
     
215.                 //转化为特定类型，std::vector重载版本
     
216.                 template <typename T> operator std::vector<T>() const;
     
217.                 //获取原始数据，慎用
     
218.                 template <typename T> T& __My_base();
     
219.                 template <typename T> const T& __My_base() const;
     
220. 
     
221.                 //================================以下是各种运算符的重载==============================
     
222. 
     
223.                 //已完成部分
     
224.                 //重载<<实现输出
     
225.                 friend std::ostream& operator<<(std::ostream& os, const variant&);
     
226.                 //重载[]
     
227.                 variant& operator[](int i);
     
228.                 //const版本
     
229.                 const variant& operator[](int i) const;
     
230. 
     
231. 
     
232.                 //未完成部分
     
233.                 //工作量有点大，有时间慢慢写
     
234.                 bool operator==(const variant&);
     
235.                 template <typename T> bool operator==(const T&);
     
236.                 //template <typename T> bool friend operator== (const T&, const variant&);
     
237. 
     
238.                 bool operator!=(const variant&);
     
239.                 template <typename T> bool operator!=(const T&);
     
240.                 //template <typename T> bool friend operator!=(const T&, const variant&);
     
241. 
     
242.                 variant& operator++();
     
243.                 variant& operator--();
     
244.                 variant operator++(int);
     
245.                 variant operator--(int);
     
246. 
     
247.                 variant& operator+ (const variant&);
     
248.                 template <typename T> variant& operator+(const T&);
     
249.                 template <typename T> friend variant& operator+(const T&, const variant&);
     
250.                 variant& operator+=(const variant&);
     
251.                 template <typename T> variant& operator+= (const T&);
     
252. 
     
253.                 variant& operator- (const variant&);
     
254.                 template <typename T> variant& operator-(const T&);
     
255.                 template <typename T> friend variant& operator-(const T&, const variant&);
     
256.                 variant& operator-=(const variant&);
     
257.                 template <typename T> variant& operator-=(const T&);
     
258. 
     
259.                 variant& operator* (const variant&);
     
260.                 template <typename T> variant& operator*(const T&);
     
261.                 template <typename T> friend variant& operator*(const T&, const variant&);
     
262.                 variant& operator*=(const variant&);
     
263.                 template <typename T> variant& operator*=(const T&);
     
264. 
     
265.                 variant& operator/ (const variant&);
     
266.                 template <typename T> variant& operator/(const T&);
     
267.                 template <typename T> friend variant& operator/(const T&, const variant&);
     
268.                 variant& operator/=(const variant&);
     
269.                 template <typename T> variant& operator/=(const T&);
     
270. 
     
271.                 variant& operator% (const variant&);
     
272.                 template <typename T> variant& operator%(const T&);
     
273.                 template <typename T> friend variant& operator%(const T&, const variant&);
     
274.                 variant& operator%=(const variant&);
     
275.                 template <typename T> variant& operator%=(const T&);
     
276. 
     
277. 
     
278.         };
     
279.         //=============================================================================
     
280.         //以下是周边函数的声明
     
281.         //=============================================================================
     
282.         //错误信息，debug模式下输出错误信息，release模式下直接抛出异常
     
283.         void ErrorMsg(std::string s);
     
284.         //由字符串转化为variant，特色功能
     
285.         variant Variant_Read(const std::string&);
     
286.         //可以在字符串后加_V以简化实现上述功能
     
287.         variant operator ""_V(const char* p, size_t s);
     
288. 
     
289. 
     
290.         //=============================================================================
     
291.         //声明结束，以下是模板函数的实现代码
     
292.         //=============================================================================
     
293. 
     
294.         //------------------------------------------------------------------------
     
295.         //IData类的函数
     
296.         //-------------------------------------------------------------------------
     
297.         //原始数据：类型指定错误会错误
     
298.         template<typename T>
     
299.         inline T & variant::IData::original_data()
     
300.         {
     
301.                 return dynamic_cast<_IData_templ<T>*>(this)->get_data();
     
302.         }
     
303.        
     
304. 
     
305.         //----------------------------------------------------------------------------
     
306.         //Judge类的函数
     
307.         //----------------------------------------------------------------------------
     
308. 
     
309.         //当原类型与目标类型相同时
     
310.         template<typename T, typename my_type, typename templ_arg>
     
311.         inline void variant::Judge<0, T, my_type, templ_arg>::transtype(my_type * self, variant * base)
     
312.         {
     
313.                 //什么也不做
     
314.         }
     
315. 
     
316.         //当目标类型为list但源类型不为list时，转化为长度为1的list，第一个元素即为自身
     
317.         template<typename T, typename my_type, typename templ_arg>
     
318.         inline void variant::Judge<1, T, my_type, templ_arg>::transtype(my_type * self, variant * base)
     
319.         {
     
320.                 base->_data = CreateData<list>(list({ *base }));
     
321.         }
     
322. 
     
323.         //当目标类型不为list但源类型为list时，将第一个元素转化为目标元素
     
324.         template<typename T, typename my_type, typename templ_arg>
     
325.         inline void variant::Judge<2, T, my_type, templ_arg>::transtype(my_type * self, variant * base)
     
326.         {
     
327.                 *base = base[0];
     
328.                 base->set_type<T>();
     
329.         }
     
330. 
     
331.         //当源类型能转化为目标类型时，进行默认转化
     
332.         template<typename T, typename my_type, typename templ_arg>
     
333.         inline void variant::Judge<3, T, my_type, templ_arg>::transtype(my_type * self, variant * base)
     
334.         {
     
335.                 base->_data = CreateData<T>(self->get_data());
     
336.         }
     
337. 
     
338.         //当源类型不能转化为目标类型时，设为默认值
     
339.         template<typename T, typename my_type, typename templ_arg>
     
340.         inline void variant::Judge<4, T, my_type, templ_arg>::transtype(my_type * self, variant * base)
     
341.         {
     
342.                 base->_data = CreateData<T>(T());
     
343.         }
     
344. 
     
345.         template<typename T, typename my_type, typename templ_arg>
     
346.         inline T variant::Judge<1, T, my_type, templ_arg>::get_data(my_type * self) {
     
347.                 return static_cast<T>(self->get_data());
     
348.         }
     
349. 
     
350.         template<typename T, typename my_type, typename templ_arg>
     
351.         inline T variant::Judge<0, T, my_type, templ_arg>::get_data(my_type * self) {
     
352. #ifdef VARIANT_STRICT_TYPE_CHECK
     
353.                 std::string s = std::string(typeid(T).name()) + "与" + typeid(templ_arg).name() + "的类型无法匹配";
     
354.                 ErrorMsg(s);
     
355. #endif
     
356.                 return T();
     
357.         }
     
358. 
     
359.         //------------------------------------------------------------------------------------
     
360.         //variant自身的函数
     
361.         //----------------------------------------------------------------------------------------
     
362. 
     
363.         template<typename T>
     
364.         inline variant::variant(const T & t) {
     
365.                 operator=(t);
     
366.         }
     
367. 
     
368. 
     
369.         template<typename T>
     
370.         inline bool variant::is_type() const
     
371.         {
     
372.                 IData *p = &*_data;
     
373.                 return dynamic_cast<_IData_templ <T>*>(p) != nullptr;
     
374.         }
     
375.        
     
376.         template<>
     
377.         inline bool variant::is_type<void>() const {
     
378.                 return !_data;
     
379.         }
     
380. 
     
381. 
     
382.         template<typename T>
     
383.         inline variant & variant::set_type()
     
384.         {
     
385.                 if (!_data) {
     
386.                         _data = CreateData<T>();
     
387.                 }
     
388.                 _data->trans_type<T>(this);
     
389.                 return *this;
     
390.         }
     
391. 
     
392. 
     
393.         template<typename ...TArgs>
     
394.         struct SendArgs {
     
395.                 template <typename retT, typename T>
     
396.                 static retT call(retT(*fp)(TArgs..., T), variant lst_v, int i, TArgs...args) {
     
397.                         return fp(args..., lst_v[i]);
     
398.                 }
     
399. 
     
400.                 template <typename retT, typename T>
     
401.                 static retT call(retT(*fp)(TArgs..., T&), variant lst_v, int i, TArgs...args) {
     
402.                         return fp(args..., lst_v[i].__My_base<T>());
     
403.                 }
     
404. 
     
405.                 template <typename retT, typename T, typename ...TArgs2>
     
406.                 static retT call(retT(*fp)(TArgs..., T, TArgs2...), variant lst_v, int i, TArgs...args) {
     
407.                         return SendArgs<TArgs..., T>::call(fp, lst_v, i + 1, args..., lst_v[i]);
     
408.                 }
     
409. 
     
410.                 template <typename retT, typename T, typename ...TArgs2>
     
411.                 static retT call(retT(*fp)(TArgs..., T&, TArgs2...), variant lst_v, int i, TArgs...args) {
     
412.                         return SendArgs<TArgs..., T&>::call(fp, lst_v, i + 1, args..., lst_v[i].__My_base<T>());
     
413.                 }
     
414. 
     
415.                 template <typename T>
     
416.                 static void call(void(*fp)(TArgs..., T), variant lst_v, int i, TArgs...args) {
     
417.                         fp(args..., lst_v[i]);
     
418.                 }
     
419. 
     
420.                 template <typename T>
     
421.                 static void call(void(*fp)(TArgs..., T&), variant lst_v, int i, TArgs...args) {
     
422.                         fp(args..., lst_v[i].__My_base<T>());
     
423.                 }
     
424. 
     
425.                 template < typename T, typename ...TArgs2>
     
426.                 static void call(void(*fp)(TArgs..., T, TArgs2...), variant lst_v, int i, TArgs...args) {
     
427.                         SendArgs<TArgs..., T>::call(fp, lst_v, i + 1, args..., lst_v[i]);
     
428.                 }
     
429. 
     
430.                 template < typename T, typename ...TArgs2>
     
431.                 static void call(void(*fp)(TArgs..., T&, TArgs2...), variant lst_v, int i, TArgs...args) {
     
432.                         SendArgs<TArgs..., T&>::call(fp, lst_v, i + 1, args..., lst_v[i].__My_base<T>());
     
433.                 }
     
434. 
     
435.         };
     
436.         template<typename retT, typename ...TArgs>
     
437.         inline retT variant::call(retT(*fp)(TArgs...))
     
438.         {
     
439.                 variant temp = *this;
     
440.                 temp.set_type<list>();
     
441.                 list l = temp._data->original_data<list>();
     
442.                 return SendArgs<>::call(fp, temp, 0);
     
443.         }
     
444. 
     
445.         template<typename ...TArgs>
     
446.         inline void variant::call(void(*fp)(TArgs...))
     
447.         {
     
448.                 variant temp = *this;
     
449.                 temp.set_type<list>();
     
450.                 list l = temp._data->original_data<list>();
     
451.                 SendArgs<>::call(fp, temp, 0);
     
452.         }
     
453. 
     
454. 
     
455.         template<typename T>
     
456.         variant & variant::operator=(const T & t)
     
457.         {
     
458.                 _data = CreateData<T>(t);
     
459.                 return *this;
     
460.         }
     
461. 
     
462. 
     
463.         //赋值函数
     
464.         //当右值为std::vector时，类型统一为list(std::vector<variant>)
     
465.         template<typename T>
     
466.         inline variant & variant::operator=(const std::vector<T>& v)
     
467.         {
     
468.                 _data = CreateData<list>(v);
     
469.                 return *this;
     
470.         }
     
471. 
     
472.         template<typename T>
     
473.         inline variant::operator T() const
     
474.         {
     
475.                 if (_data == nullptr) {
     
476.                         return T();
     
477.                 }
     
478.                 return _data->get_data<T>();
     
479.         }
     
480. 
     
481.         template<typename T>
     
482.         inline T & variant::__My_base()
     
483.         {
     
484.                 assert(is_type<T>());
     
485.                 return _data->original_data<T>();
     
486.         }
     
487. 
     
488.         template<typename T>
     
489.         inline const T & variant::__My_base() const
     
490.         {
     
491.                 assert(is_type<T>());
     
492.                 return _data->original_data<T>();
     
493.         }
     
494. 
     
495.         template<typename T>
     
496.         inline variant::operator std::vector<T>() const
     
497.         {
     
498.                 if (!is_type<list>()) {
     
499.                         ErrorMsg("variant不是list类型，无法转化为std::vector");
     
500.                         return std::vector<T>();
     
501.                 }
     
502.                 std::vector<T> ret;
     
503.                 for (int i = 0; i < this->size(); ++i) {
     
504.                         ret.push_back(this->operator[](i));
     
505.                 }
     
506.                 return ret;
     
507.         }
     
508. };
     
509. 
     
510. #endif

复制代码

Croper

3.variant_data.h

1. #ifndef __VARIANT_DATA_H
   
2. #define __VARIANT_DATA_H
   
3. #include <string>
   
4. #include <vector>
   
5. #include <unordered_map>
   
6. #include <stack>
   
7. #include "variant.h"
   
8. 
   
9. namespace croper {
   
10.         template <typename T>
    
11.         class Data :public variant::_IData_templ<T> {
    
12.         public:
    
13.                 T data;
    
14.                 Data() {};
    
15.                 Data(const T& t) :data(t) {};
    
16.                 T& get_data() override;
    
17.                 std::string mytype() const override;
    
18.                 Data* copy() const override;
    
19.                 std::string to_string() const override;
    
20.         };
    
21. 
    
22. 
    
23.         template<typename T>
    
24.         inline T& Data<T>::get_data() {
    
25.                 return data;
    
26.         }
    
27. 
    
28.         template<typename T>
    
29.         inline std::string Data<T>::mytype() const {
    
30.                 return typeid(data).name();
    
31.         }
    
32. 
    
33.         template<>
    
34.         inline std::string Data<std::string>::mytype() const {
    
35.                 return "string";
    
36.         }
    
37. 
    
38.         template<>
    
39.         inline std::string Data<variant::list>::mytype() const {
    
40.                 return "list";
    
41.         }
    
42. 
    
43.         template<typename T>
    
44.         inline Data<T> * Data<T>::copy() const {
    
45.                 return new Data(*this);
    
46.         }
    
47. 
    
48.         template<typename T>
    
49.         inline std::string Data<T>::to_string() const {
    
50.                 return std::to_string(data);
    
51.         }
    
52. 
    
53.         template <>
    
54.         inline std::string Data<std::string>::to_string() const {
    
55.                 return data;
    
56.         }
    
57. 
    
58.         template <>
    
59.         inline std::string Data<bool>::to_string() const {
    
60.                 return data ? "(true)" : "(false)";
    
61.         }
    
62. 
    
63. 
    
64.         //使用图的dps算法来构造当data的type为list时的字符串算法
    
65.         //不能使用树的dps算法，可能会有环路。
    
66.         template <>
    
67.         inline std::string Data<std::vector<variant>>::to_string() const {       
    
68.                 using list = variant::list;
    
69.                 struct ele {
    
70.                         const list* p;
    
71.                         int index;
    
72.                 };
    
73.                 struct map_ele {
    
74.                         int state;
    
75.                         std::string sz;
    
76.                         map_ele() :state(0), sz("") {};
    
77.                 };
    
78.                 std::unordered_map<const list*,map_ele> checked;
    
79.                 std::stack<ele> stk;
    
80.                 const list* p = &data;
    
81.                 stk.push({ p,0 });
    
82.                 checked[p].sz = "[";
    
83.                 while (!stk.empty()) {
    
84.                         checked[p].state = 1;
    
85.                         int &i = stk.top().index;
    
86.                         do {
    
87.                                 std::string& sz = checked[p].sz;
    
88.                                 const variant& v = (*p)[i];
    
89.                                 if (!v.is_type<list>()) {
    
90.                                         sz += v.to_string();
    
91.                                         sz += ",";
    
92.                                 }
    
93.                                 else {
    
94.                                         map_ele& e = checked[&v.__My_base<list>()];
    
95.                                         if (e.state == 2) {
    
96.                                                 sz += e.sz;
    
97.                                                 sz += ',';
    
98.                                         }
    
99.                                         else if (e.state == 1) {
    
100.                                                 sz += "[...]";
     
101.                                                 sz += ',';
     
102.                                         }
     
103.                                         else
     
104.                                         {
     
105.                                                 p = &v.__My_base<list>();
     
106.                                                 stk.push({ p,0 });
     
107.                                                 checked[p].sz = "[";
     
108.                                                 break;
     
109.                                         }
     
110.                                 }
     
111.                         } while (++i < p->size());
     
112.        
     
113. 
     
114.                         while (stk.top().index == p->size()) {
     
115.                                 if (p->empty()) {
     
116.                                         checked[p].sz.push_back(']');
     
117.                                 }
     
118.                                 else {
     
119.                                         checked[p].sz.back() = ']';
     
120.                                 }
     
121.                                 checked[p].state = 2;
     
122.                                 std::string& sz = checked[p].sz;
     
123.                                 stk.pop();
     
124.                                 if (stk.empty()) break;
     
125.                                 p = stk.top().p;
     
126.                                 checked[p].sz += sz;
     
127.                                 checked[p].sz +=',';
     
128.                                 stk.top().index++;
     
129.                         }
     
130.                 }
     
131.        
     
132.                 return checked[&data].sz;
     
133.         }
     
134. 
     
135.         template <typename T>
     
136.         inline std::shared_ptr<variant::IData> variant::CreateData() {
     
137.                 return std::make_shared<Data<T>>();
     
138.         }
     
139. 
     
140.         template <typename T>
     
141.         inline std::shared_ptr<variant::IData> variant::CreateData(const T& t) {
     
142.                 return std::make_shared<Data<T>>(t);
     
143.         }
     
144. };
     
145. 
     
146. #endif

复制代码

Croper

4、variant.h 使用时包含这个就好

1. //=======================================================================================
   
2. //--------------------------------------------------------------------------------------|
   
3. //variant类                                                                                                                                                                |       
   
4. //Created by Croper                                                                            |
   
5. //last modified at Jan.15 2020                                                          |
   
6. //仿python变量的变体类。                                                                                                                                |
   
7. //主要分为两部分 Variant和Data                                                                                                                        |
   
8. //variant本身是一个智能指针的包装，作为表层数据，指向Data                                                                |
   
9. //Data是一个实际类型的包装，本身是模板，共同拥有一个接口IData                                                        |
   
10. //--------------------------------------------------------------------------------------|
    
11. //========================================================================================
    
12. 
    
13. #ifndef __VARIANT_H
    
14. #define __VARIANT_H
    
15. 
    
16. #ifndef VARIANT_REGISTER_TYPE
    
17. #define VARIANT_REGISTER_TYPE \
    
18.         VARIANT_REGISTER(int)\
    
19.         VARIANT_REGISTER(double)\
    
20.         VARIANT_REGISTER(bool)\
    
21.         VARIANT_REGISTER(string)\
    
22.         VARIANT_REGISTER(list)
    
23. #endif
    
24. 
    
25. #include "variant_meta.h"
    
26. #include "variant_struct.h"
    
27. #include "variant_data.h"
    
28. 
    
29. #endif

复制代码

Croper

然后还有一个variant.cpp

1. 
   
2. #include <sstream>
   
3. #include <stack>
   
4. #include <string>
   
5. #include "variant.h"
   
6. using namespace std;
   
7. namespace croper {
   
8.         const variant variant::None = variant();
   
9.         using list = variant::list;
   
10.         void ErrorMsg(string s)
    
11.         {
    
12. #ifdef _DEBUG
    
13.                 cerr << s << endl;
    
14. #else
    
15.                 throw "s";
    
16. #endif
    
17.         }
    
18. 
    
19.         ostream & operator<<(ostream & os, const variant &t)
    
20.         {
    
21.                 if (t._data == nullptr) {
    
22.                         os << "(None)";
    
23.                         return os;
    
24.                 }
    
25.                 os << t._data->to_string();
    
26.                 return os;
    
27.         }
    
28. 
    
29.         //========================================================================================
    
30.         //以下是variant的函数
    
31. 
    
32. 
    
33. 
    
34.         //构造函数
    
35.         variant::variant() {};
    
36.         variant::variant(const initializer_list<variant>& l)
    
37.         {
    
38.                 set_type<list>();
    
39.                 for (auto v : l) {
    
40.                         append(v);
    
41.                 }
    
42.         }
    
43.         variant Variant_Read_Simple(string& sz, int digit_type) {
    
44.                 variant v0;
    
45.                 if (sz.empty()) {
    
46.                         return v0;
    
47.                 }
    
48.                 else if (digit_type == 0) {
    
49.                         stringstream ss(sz);
    
50.                         int i;
    
51.                         ss >> i;
    
52.                         v0 = i;
    
53.                 }
    
54.                 else if (digit_type == 1) {
    
55.                         stringstream ss(sz);
    
56.                         double d;
    
57.                         ss >> d;
    
58.                         v0 = d;
    
59.                 }
    
60.                 else if (digit_type == 2) {
    
61.                         if (sz == "true" || sz == "True") {
    
62.                                 v0 = true;
    
63.                         }
    
64.                         else if (sz == "false" || sz == "False") {
    
65.                                 v0 = false;
    
66.                         }
    
67.                         else {
    
68.                                 if (sz.size() >= 2 && sz[0] == sz.back() && (sz[0] == '\'' || sz[0] == '"')) {
    
69.                                         sz = sz.substr(1, sz.size() - 2);
    
70.                                 }
    
71.                                 v0 = sz;
    
72.                         }
    
73.                 }
    
74.                 return v0;
    
75.         }
    
76.         variant Variant_Read(const string& sz)
    
77.         {
    
78.                 variant ret;
    
79.                 stack<variant*> stk;
    
80.                 stk.push(&ret);
    
81.                 bool Recording = false;                //是否正在记录
    
82.                 int digit_type = 0;                        //0为整数，1为浮点数，2为字符串
    
83.                 bool transfered = false;        //转义标签，上一个字符串是否为转义符。
    
84.                 string temp;
    
85. 
    
86.                 ret.set_type<list>();
    
87.                 for (const char* p = sz.c_str();; p++) {
    
88.                         const char& c = *p;
    
89.                         variant& v = *stk.top();
    
90.                         if (Recording && c == '\0' || !transfered && c == ',' || Recording && !transfered && (c == '[' || c == ']')) {  //结算当前字符串
    
91.                                 variant v0= Variant_Read_Simple(temp,digit_type);
    
92.                                 v.append(v0);
    
93.                                 Recording = false;
    
94.                                 if (*p == ',') {
    
95.                                         continue;
    
96.                                 }
    
97.                         }
    
98.                         if (!transfered && *p == '[') {
    
99.                                 v.append(variant());
    
100.                                 v.back().set_type<list>();
     
101.                                 stk.push(&v.back());
     
102.                                 continue;
     
103.                         }
     
104.                         else if (!transfered && *p == ']') {
     
105.                                 stk.pop();
     
106.                                 if (stk.empty()) {
     
107.                                         break;
     
108.                                 }
     
109.                                 continue;
     
110.                         }
     
111.                         else if (!transfered && !Recording && (*p == ' ' || *p == '\n' || *p == '\t')) {
     
112.                                 continue;
     
113.                         }
     
114.                         else if (*p == '\0') {
     
115.                                 break;
     
116.                         }
     
117.                         else {
     
118.                                 if (!transfered && *p == '//') {
     
119.                                         transfered = true;
     
120.                                         continue;
     
121.                                 }
     
122.                                 if (!Recording) {
     
123.                                         Recording = true;
     
124.                                         digit_type = 0;
     
125.                                         temp.clear();
     
126.                                 }
     
127.                                 while (digit_type < 2) {
     
128.                                         if (!isdigit(*p) && *p != '-' && *p != '.') {
     
129.                                                 digit_type = 2;
     
130.                                                 break;
     
131.                                         }
     
132.                                         if (*p == '-' && !temp.empty()) {
     
133.                                                 digit_type = 2;
     
134.                                                 break;
     
135.                                         }
     
136.                                         if (*p == '.') {
     
137.                                                 digit_type += 1;
     
138.                                                 break;
     
139.                                         }
     
140.                                         break;
     
141.                                 }
     
142.                                 temp.push_back(*p);
     
143.                         }
     
144.                 }
     
145.                 if (ret.size() == 0) {
     
146.                         return variant();
     
147.                 }
     
148.                 else if (ret.size() == 1) {
     
149.                         return ret[0];
     
150.                 }
     
151.                 return ret;
     
152.         }
     
153. 
     
154.         void variant::clear()
     
155.         {
     
156.                 _data = nullptr;
     
157.         }
     
158.         string variant::to_string() const
     
159.         {
     
160.                 if (_data == nullptr) {
     
161.                         return "(None)";
     
162.                 }
     
163.                 return _data->to_string();
     
164.         }
     
165.         void variant::append(const variant & v)
     
166.         {
     
167.                 if (!is_type<list>()) {
     
168.                         ErrorMsg("错误:variant的类型不是list，无法使用append方法");
     
169.                         return;
     
170.                 }
     
171.                 _data->original_data<list>().push_back(v);
     
172.         }
     
173. 
     
174.         size_t variant::size() const
     
175.         {
     
176.                 if (!is_type<list>()) {
     
177.                         ErrorMsg("错误:variant的类型不是list，无法使用size方法");
     
178.                         return -1;
     
179.                 }
     
180.                 return _data->original_data<list>().size();
     
181.         }
     
182. 
     
183.         variant& variant::back()
     
184.         {
     
185.                 if (!is_type<list>()) {
     
186.                         ErrorMsg("错误:variant的类型不是list，无法使用back方法");
     
187.                         return *this;
     
188.                 }
     
189.                 return _data->original_data<list>().back();
     
190.         }
     
191. 
     
192.         variant & variant::operator=(const char * sz)
     
193.         {
     
194.                 _data = CreateData<string>(sz);
     
195.                 return *this;
     
196.         }
     
197. 
     
198. 
     
199.         variant & variant::operator[](int i)
     
200.         {
     
201.                 if (is_type<list>()) {
     
202.                         return _data->original_data<list>()[i];
     
203.                 }
     
204. #ifdef VARIANT_REGISTER_TYPE
     
205.                 ErrorMsg("variant的内部类型不是list");
     
206. #endif
     
207.                 return *this;
     
208.         }
     
209. 
     
210.         const variant & variant::operator[](int i) const
     
211.         {
     
212.                 if (is_type<list>()) {
     
213.                         return _data->original_data<list>()[i];
     
214.                 }
     
215. #ifdef VARIANT_REGISTER_TYPE
     
216.                 ErrorMsg("variant的内部类型不是list");
     
217. #endif
     
218.                 return *this;
     
219.         }
     
220. 
     
221.         bool variant::operator==(const variant & v2)
     
222.         {
     
223.                 if (_data == v2._data) return true;
     
224.                 return false;
     
225.         }
     
226. 
     
227.         string variant::type() const
     
228.         {
     
229.                 if (_data == nullptr) {
     
230.                         return "void";
     
231.                 }
     
232.                 return _data->mytype();
     
233.         }
     
234. 
     
235.         variant operator ""_V(const char* p, size_t s) {
     
236.                 return Variant_Read(p);
     
237.         }
     
238. }

复制代码

Croper

用途嘛。。最初时拿来刷leetcode的题。。。。
现在看来把运算符完善了能搞一些泛型编程，

有兴趣的也可以吐槽下代码，欢迎发表批评，建议，感叹什么的。。
另附github地址