C++模板杂谈

在模板编程中，有几个常用的技术：模板（偏）特化，特性萃取，标签分派，匹配失败不是错误。其中模板（偏）特化是基础，匹配失败不是错误(SFINAE）应用最为广泛。

现代C++对模板编程做了更多的加强，boost.hana又结合constexpr和lambda把类型与值的计算统一了起来。放眼C++世界，尤其是C++库，几乎都是使用模板的泛型编程。

话说在C++的世界中（并且几乎所有语言中）函数的作用是最为明显的，试想：没有类也可以完成编程任务，但没有函数却不好说。另一方向只使用变量和语句也能完成少量的工作，但不进行函数的封装终难成大事。这几年函数式编程赿来赿流行，与函数的重要性不无关系。所以无论是用类也罢，用函数也罢，或者使用C++新增的变量模板，我们的思路是始终围绕着把它们向函数上靠就好。从MPL的元函数开始就试图使类尽可能像函数，我们在模板编程中也要使模板类、模板变量、乃至模板函数都向“函数”靠拢。这里函数加上引号我想表达的是包括但不限于constexpr函数。

一、先从类型计算将用类实现来转为用函数实现起。将类型计算与值计算统一起来，以例子说话：

 #include <type_traits>

 //1、先定义一个辅助类，为了将类型表示为对象
 template<typename T>
 struct type_t
 {
     using type = T;
 };

 //2、装饰类型，这里给类型添加指针
 template<typename T>
 constexpr auto add_pointer(type_t<T>)
 {
     return type_t<T*>{};
 }

 //3、为测试提供支持
 template<typename T>
 constexpr auto is_pointer(type_t<T>)
 {
     return std::false_type{};
 }

 template<typename T>
 constexpr auto is_pointer(type_t<T*>)
 {
     return std::true_type{};
 }

 //4、测试
 type_t<int> int_t{};
 auto p = add_pointer(int_t);

 auto is_ptr = is_pointer(p);
 static_assert(is_ptr.value,"");

 int main()
 {
     return ;
 }

我们没有用元函数式方法实现，因为STL库中实现好了。现在用函数的方式也可以实现了，仔细体会代码，函数把类型和值的计算统一了起来，看起来函数的作用更加强大了。针对以上例子，我们需要类型的时候可以这样

 // --vs2017rc仍然不能编译--
 //template<typename T>
 //using point_type =typename decltype(add_pointer(type_t<T>{}))::type;

 using point_type = typename decltype(p)::type;

稍嫌繁琐，但可以进一步封装。

 //将以上代码装到namespace中
 namespace detail {
     //...
 }

 template<typename T>
 uisng add_pointer_t = typename decltype(detail::add_pointer(type_t<T>{}))::type;

二、把类函数化。还是以例子说话：

 struct test {};

 //1、古老的仿函数
 template<typename T>
 struct func
 {
     template<typename... Args>
     auto operator()(Args&&... args) const
     {
         return T{ std::forward<Args>(args)... };
     }
 };

 func<test> func_c;
 auto test_t=func_c();

 //2、元函数，就不写例子了，STL中很多

func明明是类，但我们把它用出了函数的感觉有没有。

三、把变量模板函数化

上面的代码感觉用起来还是不爽，主要是因为还要先生成一个类对象，我们把它也封装起来，再看个例子

 struct test2
 {
     explicit test2(int x)
         : x_(x)
     {

     }

     int x_;
 };
 template<typename T>
 constexpr func<T> func_c{};

 auto test2_t = func_c<test2>();

看起来就像在调用函数了吧。

总之，不管是什么，只管往函数上靠就对了。

本来想要写sfinae来着，却强烈地想函数的事，现在记录一种利用sfinae的方式吧。

首先，当然是模板特化了。特化前先说说形式完整性这个概念：

有一个别名声明：

 template<typename...>
 using void_t=void;

这个别名声明的意思是不管你给我传多少个模板参数，可能是有效的参数我都统统把它们当做void，除非任意一个模板参数不是有效的，那样的话另说（通常是编译器会给你点颜色看看）。

今天我就是要给你无效参数了怎么地？哼哼，我有sfinae大法在手，给我脸色我还不尿你呢！

有了sfinae，编译器会妥协，不管模板参数有效无效它都不敢给你脸色啦。

嗯，我想想哈，举个标签的例子吧。设想是如果一个类有标签，那么我们获取它的标签，如果没有，就什么也不做。

     template<typename T, typename = void>
     struct tag_of;

     template<typename T>
     struct tag_of<T, void_t<typename T::tag>>
     {
         using type = typename T::tag;
     };

     template<typename T>
     using tag_of_t = typename tag_of<T>::type;

     template<typename T, typename Tag>
     struct is_tagof : std::false_type
     {

     };

     template<typename T>
     struct is_tagof<T, tag_of_t<T>> : std::true_type
     {

     };

模板（偏）特化会优先得到解析。上面is_tagof判断类型T是否有嵌入的tag，如果有，is_tagof就是true_type,如果没有的话，编译器在匹配void_t<typename T::tag>会失败，编译器不认为这是错误而是回头匹配主模板,is_tagof就是false_type