keywords
- std::enable_if
0 引言
c++ 学习笔记 之 c++11 新特性：std::enable_if
1 std::enable_if的概述
std::enable_if，满足条件时类型有效。 我们结合源码来看看（位于 type_traits 中）
// Primary template.
/// Define a member typedef @c type only if a boolean constant is true.
template<bool, typename _Tp = void>
struct enable_if
{ };
// Partial specialization for true.
template<typename _Tp>
struct enable_if<true, _Tp>
{ typedef _Tp type; };
从上面源码可以看到，只有第一个模板参数为true时，struct 才会定义一个public的type类型（struct成员默认是public类型），type即为第二个模板参数
下面看看这几个定义
std::enable_if<true, int>::type t; // OK，定义了一个变量t，类型是int
std::enable_if<false, int>::type t2 // FAIL，因为没有type这个类型，编译失败
std::enable_if<true>::type; // OK, 第一模板参数是true，第二模板参数是通常版本中定义的默认类型即void
那么std::enable_if 有什么用呢？
2 std::enable_if 的使用场景
参考 cppreference.com std::enable_if 的说明文档，总结几个使用场景如下
2.1 类型偏特化
看看下面案例
关于偏特化的知识点，后面专门分析
#include <iostream>
template<class T, class Enable = void>
class A {
public:
A() { std::cout << "primary template\r\n"; }
}; // primary template
template<class T>
class A<T, typename std::enable_if<std::is_floating_point<T>::value>::type> {
public:
A() { std::cout << "partial specialization\r\n"; }
}; // specialization for floating point types
int main() {
std::shared_ptr<A<int>> a1 = std::make_shared<A<int>>();
auto a2 = std::make_shared<A<double>>();
}
输出如下
primary template
partial specialization
从上面案例可以看到，可以通过std::enable_if，控制不同的数据类型，选择不同的类模板
2.2 函数返回值场景
通过函数的返回值，控制不同的条件下，选择不同的模板。直接看看下面代码案例
#include <iostream>
// enabled via the return type
template<class T>
typename std::enable_if<std::is_trivially_default_constructible<T>::value>::type
construct(T *) {
std::cout << "default constructing trivially default constructible T\n";
}
template<class T>
typename std::enable_if<!std::is_trivially_default_constructible<T>::value>::type
construct(T *p) {
std::cout << "default constructing non-trivially default constructible T\n";
}
int main() {
int a = 1;
std::string str = "hell";
construct(&a);
construct(&str);
return 0;
}
输出如下
default constructing trivially default constructible T
default constructing non-trivially default constructible T
2.3 函数参数场景
通过函数的参数，控制不同的条件下，选择不同的模板。看看下面案例
#include <iostream>
// enabled via a parameter
template<class T>
void destroy(T *,
typename std::enable_if<std::is_trivially_destructible<T>::value>::type * = 0) {
std::cout << "destroying trivially destructible T\n";
}
// enabled via a non-type template parameter
template<class T, typename std::enable_if<!std::is_trivially_destructible<T>{} &&
(std::is_class<T>{} || std::is_union<T>{}),bool>::type = true>
void destroy(T* t)
{
std::cout << "destroying non-trivially destructible T\n";
}
int main() {
int a = 1;
std::string str = "hell";
destroy(&a);
destroy(&str);
return 0;
}
输出如下：
destroying trivially destructible T
destroying non-trivially destructible T
上面参考官方文档列举了几个使用场景。 后面会根据实际应用补充场景以及理解。
99 拓展
在官方的介绍文档里面，提到了SFINAE(Substitution failure is not an error)，下面简单介绍下这个概念，先看看下面代码
#include <iostream>
struct B { typedef int type; };
template<class T>
typename T::type h(typename B::type) { std::cout << "h special\r\n"; }
template<class T>
void h(T t) { std::cout << "h common\r\n"; }
int main() {
h<B>(10);
h<int>(10);
return 0;
}
输出为
h special
h common
上面就是官方的代码，我简化了下。 从上面输出看，两个函数调用都正确推导到了各自的函数模板。SFINAE 就是如果推导模板函数可以找到一个正确的版本，过程中即使存在模板匹配时的语法错误，编译器也不会报错，比如上述的 int::type，是存在语法错误的
