C++ 模板元中巧用异常让字符串储存在指定类型的tuple中



std::tuple_element<0,std::tuple<...>>::type
	std::tuple_element<1,std::tuple<...>>::type

        数据储存在文本中那么都是字符串，所以当需要处理数据的时候需要将字符串转换成相应的类型，这本来没什么，只需要知道类型即可转换，那么如何将一个字符串转换到指定类型的tuple中呢？因为把参数放进数据放进tuple中有很多好处，简单点说在操作lua函数中可以带来很大的便利，好吧，就算不在C++中使用lua，那么统一管理数据也是很好的，再比如在操纵函数过程中用来打包函数参数也是很好的.

        假如有一个函数需要int，float，float的参数，而这些参数我们大概可能是从文件中读取，那么他们是字符串，通常一般大概都会这么做，知道参数类型，将字符串转换成相应的类型的数据，然后调用函数，问题来了，这样硬编码是不是真的很好呢？

void test(int i, double b){
		std::cout << i << std::endl;
		std::cout << b << std::endl;
	}
	double test(int i, double b,double c){
		std::cout << i << std::endl;
		std::cout << b << std::endl;
		std::cout << c << std::endl;
		return i*b*c;
	}

        typedef double(*F)(int, double, double);
	F __f = test;
	std::string str;	
	std::cin>>str;
	ManualFun(__f, str); // 使用输入的参数调用函数

         如果我们想要达到上面的效果，我们通常会根据函数特性来根据参数类型把字符串转换到tuple，在将tuple解包得到我们要的函数执行所必须的参数即可，当然这些都在内部函数的调用中完成，所以比较简单，这里就不多说，下面我们来看看怎么将那个储存参数的tuple提取出来。

         嗯，为什么说把储存参数的tuple提取出来需要拿出来说一下呢？因为tuple的操作都是使用了大量的模板，其实就是tuple就是一个跨越编译期和运行期的一个模板元应用，所以操作tuple不能像操作一般的容器对待，这是因为每一次操作tuple其实都是在操作一个临时的类型不同的对象。简单点说，你要检查tuple的每一个数据的类型都是一个模板的不同实例化：

        

	std::tuple_element<0,std::tuple<...>>::type
	std::tuple_element<1,std::tuple<...>>::type

          同样是获取tuple中元素的类型，但是不同的元素就是使用tuple_element的不同实例化，也就是说std::tuple_element<0,std::tuple<...>> 和 std::tuple_element<1,std::tuple<...>> 就像大圣和白龙马一样没啥关系。而问题是我们想要让字符串转换到指定的tuple中我们就要知道tuple中每一个元素的类型。所以，这样一来，还是逃离不了使用模板元的节奏。

        

	template<size_t index,size_t M,class T>
	struct TypeConvert;

	template<size_t index, size_t M, class ... Args>
	struct TypeConvert<index, M, std::tuple<Args...>>{
		typedef typename std::tuple_element<index, std::tuple<Args...>>::type Type;
		template<class T>
		struct Apply{
			Apply(T t) :mT(t){}
			inline void apply(std::vector<MString>& v)
			{
				MString str = v.front();
				v.erase(v.begin());
				auto tt = std::tuple_cat(mT, std::make_tuple(str.ToOtherType<Type>()));
				TypeConvert<index + 1, M, std::tuple<Args...>>::Apply<decltype(tt)>(tt).apply(v);
			}
			T mT;
		};
		
	};

	template<size_t M,class ... Args>
	struct TypeConvert<M,M,std::tuple<Args...>>{
		typedef  typename std::tuple_element<M-1, std::tuple<Args...>>::type Type;
		template<class T>
		struct Apply{
			Apply(T t) :mT(t){}
			inline void apply(std::vector<MString>& v)
			{
				;
			}
			T mT;
		};
		
	};
	
	template<class...Args>
	std::tuple<Args...>& Totuple(const std::string& str, std::tuple<Args...>& output){
		MString Mstr = str;
		std::vector<MString> v;
		Mstr.split(" \t", v);
		if (v.size() < sizeof...(Args)){
			return output;
		}
		TypeConvert<0, sizeof...(Args), std::tuple<Args...>>::Apply<std::tuple<>>(std::tuple<>()).apply(v);
		return output;  // 这里不是我们想要的结果
	}

          好吧，到现在为止，我们确实是将字符串的内容转换到tuple里面了，mT就是储存结果的，但是问题来了，我们该怎么获取这最后一个mT呢？
 
          当然下面的使用方式是不可以的：

	inline auto apply(std::vector<MString>& v)->decltype(...............)
	{
		return mT;
	}

         就算通过各种技巧将返回类型给推导出来，那代码大概也是相当难看的，之所以不这么做，是因为可以很简单的获取我们想要的结果，那就是异常，只需要在递归终止时将结果当做异常抛出来即可：

       

	inline auto apply(std::vector<MString>& v)->decltype(...............)
	{
		throw mT;
	}

             然后在ToTuple函数中抓一下异常：

	template<class...Args>
	std::tuple<Args...>& Totuple(const std::string& str, std::tuple<Args...>& output){
		MString Mstr = str;
		std::vector<MString> v;
		Mstr.split(" \t", v); // 使用空格来或者\t来分隔字符串
				      // MString是自己写的一个字符串库，使用boost里的算法也能够完成这些操作
		if (v.size() < sizeof...(Args)){
			return output;
		}
		try{
			TypeConvert<0, sizeof...(Args), std::tuple<Args...>>::Apply<std::tuple<>>(std::tuple<>()).apply(v);
		}
		catch (std::tuple<Args...> e){
			output = std::forward<std::tuple<Args...>&&>(e);
			return output;  // 这里就是我们想要的结果
		}
		catch (...){
			return output; // 如果得到的结果不是我们想要的
		}
	}

         有木有觉得很巧妙呢？在对输出流操作符重载一下让他可以接受输入是不是更好呢？

	template<class...Args>
	inline std::istream& operator>>(std::istream& is, std::tuple<Args...>& t){
		std::string str;
		std::getline(is, str);
		if (str.empty())
			return is;
		t = Totuple(str, t);
		return is;
	}

          现在可以这么来对tuple进行操作，还能够从文件中读取数据并保存在指定的类型中：

	std::tuple<int, float, float> t;
	Totuple("10 20.3 30.5",t); 
	std::cout << t << std::endl;
	std::cin >> t;
	std::cout << t << std::endl;

           说了这些，其实是想说，异常有时候不仅仅只是标识错误的发生，他还能够帮我们解决很多事，我就不说以前就干过用异常来传递数据的事了。