目录

• 1.std::void_t 的原理
• 2.std::void_t 的应用
• 3.std::void_t 与 std::enable_if

1.std::void_t 的原理

std::void_t<> 是 C++ 17 标准增加的一个非常实用的功能，其实就是一个模板别名的定义，它的作用是将一系列不同的类型映射成 void 类型。在 C++ 20 的概念（concept）推出之前，它被认为是使用 SFINAE 机制的最方便的方法之一。std::void_t<> 根据对一个表达式（比如用 decltype 推断一个操作数的类型的表达式）的有效性判断，从候选集中移除某些符合条件的模板函数或模板类，从而允许特定的函数重载或类模板的特化版本成立。

标准库中这样定义 std::void_t：

template <class... _Types>
using void_t = void;

std::void_t<> 定义了一个模板别名，它的作用是将模板参数列表中的 _Types 映射成 void 类型。这个别名能工作的前提是 _Types 中的每种类型都必须是合法的类型，若 _Types 中包含不合法的类型，则这个别名的定义非法，从而触发 SFINAE 机制产生相应的效果。std::void_t<> 的灵活性在于 _Types 甚至可以是 decltype() 表达式，比如 std::void_t<decltype(5)> 。这个表达式不会触发模板参数替换失败，因为 decltype(5) 推断得到 int 类型，整个表达式最终的结果相当于 void。但是 std::void_t<decltype(std::string::to_integer)> 就会失败，因为目前标准库的 std::string 没有名为 to_integer 的成员，decltype 推断不出一个合法的类型。这就是 std::void_t<>的工作原理，当 std::void_t<> 替换失败时，就会触发 SFINAE 机制删除相应的模板参数替换得到的错误结果。

2.std::void_t 的应用

2.1.判断成员存在性

2.1.1.判断嵌套类型定义

std::void_t<> 可以用来判断一个类型 T 是否嵌套定义了某个类型。判断的原理就是利用 T::SomeType 类型的存在性，转化成 std::void_t<T::SomeType> 定义的合法性。来看下面的例子，判断某个类型是否内部嵌套定义了子类型：InnerType：

template< class, class = std::void_t<> >  //或者 template< class, class = void >
struct has_type_member : std::false_type { };
 
template< class T >
struct has_type_member<T, std::void_t<typename T::InnerType>> : std::true_type { };
 
// 演示代码
struct ObjectA {
    enum class InnerType { COLOR, SHAPE };
};
struct ObjectB {
    using InnerType = int;
};
struct ObjectC {
};
 
static_assert(has_type_member<ObjectA>::value); //true, ObjectA 有 enum 类型的 InnerType 定义
static_assert(has_type_member<ObjectB>::value); //true, ObjectB 有 int 类型别名 InnerType
static_assert(has_type_member<ObjectC>::value); //false，ObjectC 没有 InnerType

这里说明一下，因为 `std::void_t<>` 定义中的`_Types`是一个变长参数列表，可以是空，所以当 `_Types` 为空的时候也是一个合法的模板别名，即 `std::void_t<> == void`。上述代码中的 `class = std::void_t<>` 很多人也直接写成 `class = void`，效果是一样的。模板实例化过程中的匹配顺序，`void` 总是优先级最低的，所以编译器总是优先匹配第二个 `has_type_member<>` 定义（`has_type_member<>`的偏特化版本），得到`std::true_type<>`定义的 `value`。只有当 `T::InnerType` 不存在，导致`std::void_t<>` 定义失败的时候，编译器才会继续匹配第一个 `has_type_member<>` 的泛化版本。`has_type_member<>` 的泛化版本虽然因为 `void` 优先级低，总是最后才轮到，但是它能匹配任意情况，得到`std::false_type<>`定义的 `value`。根据 SFINAE 机制，编译器对之前的失败也不报错，于是 `has_type_member<>` 就完美地实现了自己的设计意图。

`std::false_type<>` 和 `std::true_type<>` 是 `std::integral_constant<>` 的一个特化版本，`has_type_member<>`借助这个继承关系得到了一个类型为 bool 的静态变量 value。

2.1.2 判断成员是否存在

借助于上一节的思路，判断一个类型中是否存在某个数据成员的方法非常简单，但是需要注意的是，因为`MemberName` 是数据成员的名字，所以`T::MemberName`就不是一个类型了，不能用做`std::void_t<>`的模板参数。这时候就要用到 `decltype()`了，让编译器推导出数据成员的类型：

template< class, class = void >
struct has_data_member : std::false_type { };
 
template< class T >
struct has_data_member<T, std::void_t<decltype(T::Tom)>> : std::true_type { };

但是对于成员函数的判断，就不能直接使用 `decltype(T::Func)`，因为这只适用于静态成员函数的情况，对于非静态的成员函数来说，T::Func 是一个非法的表达式。假设 a 是 T 类型的一个对象实例，则 `a.T::Func` 或 `a.func` 才是合法的表达式。所以对于成员函数来说，如果还是使用 `decltype(T::Func)`的语法形式，则无论的一项是否有名为 Func 的成员函数，都会因为表达式非法而替换失败，从而匹配成 false_type 的结果。难道还要构造一个 T 类型的对象才行吗？当然不是，C++ 不是还有`std::declval()`嘛。

`std::declval() `的作用是返回任意类型 T 的右值引用类型 T&& ，可以借助这个右值引用调用 T 的成员函数，最终的效果就是在没有构造 T 的任何实例的情况下调用了 T 的成员函数，当然，这一切都是在编译期间完成的，编译器甚至都不需要函数的完整定义。具体的做法就是用`std::declval() `得到对象的右值引用，然后使用这个右值引用调用成员函数，再用`decltype()`推导函数调用返回值的类型：

std::void_t<decltype(std::declval<T>().Func())>

如果 T 中存在名为 `Func`的成员函数，则`std::declval<T>().Func()`就是一个合法的函数调用表达式，`decltype()`就能推导出函数返回值的类型，`std::void_t<>`的模板参数就是一个合法的类型，于是它的别名定义就合法。如果 T 中不存在名为 `Func`的成员函数，则`std::declval<T>().Func()`不是一个合法的表达式，最终`std::void_t<>`的定义就是错误的，这会触发 SFINAE 机制删除错误的替换结果，从而达到选择的目的。

粉丝福利， 免费领取C/C++ 开发学习资料包、技术视频/项目代码，1000道大厂面试题，内容包括（C++基础，网络编程，数据库，中间件，后端开发，音视频开发，Qt开发，游戏开发，Linux内核等进阶学习资料和最佳学习路线）↓↓↓↓有需要的朋友可以进企鹅裙927239107领取哦~↓↓

根据上述分析，判断类型是否存在指定成员函数的实现可以这样做：

template<class T, class = std::void_t<>>
struct has_func_member : std::false_type {};
 
template<class T>
struct has_func_member<T, std::void_t<decltype(std::declval<T>().fun())>> : std::true_type {};
 
struct ObjectA {
    int fun() { return 42; }
};
 
struct ObjectB {
};
 
static_assert(has_func_member<ObjectA>::value);
static_assert(!has_func_member<ObjectB>::value);

2.2 判断表达式是否合法

`std::void_t<>`不仅可用于判断成员的存在性，还可用来判断表达式是否合法，实际上，2.1.2 节介绍成员函数的存在性判断时，就是利用了表达式是否合法的方式处理的。这一节，我们再介绍几个这样的例子。

2.2.1 判断是否支持前置++运算符

是的，实现思路也是尝试调用对象的前置 ++ 运算符，如果调用失败说明对象不支持前置 ++ 运算符：

template< class, class = void >
struct has_pre_increment_member : std::false_type { };
 
template< class T >
struct has_pre_increment_member<T, std::void_t< decltype(++std::declval<T&>()) > 
                                > : std::true_type { };

`std::declval<T&>()`得到一个右值引用，对这个右值引用调用前置 ++ 运算符，如果表达式合法，则`std::void_t<decltype(++std::declval<T&>())>`的定义就是合法的，`has_pre_increment_member<>` 的 true_type 特化版本实例化成为最佳匹配。反之，若对前置 ++ 运算符的调用失败，则`has_pre_increment_member<>`特化版本就得到一个错误的替换结果，编译器于是“不动声色地”按照`has_pre_increment_member<>`的泛化版本实例化出 false_type 的版本。

2.2.2 判断是否支持迭代器

C++ 标准库中的容器都支持通过 begin() 和 end() 函数获得对应的迭代器，可以借助对这两个成员函数的存在性判断一个类型是否支持迭代器，当然，这不一定严谨，我们只是用这个例子展示 `std::void_t<>`的更多用法。

template <typename, typename = void>
struct is_iterable : std::false_type {};
 
template <typename T>
struct is_iterable<T, 
                   std::void_t< decltype(std::declval<T>().begin()), decltype(std::declval<T>().end()) > 
                   > : std::true_type {};

对了，谁说 `std::void_t<>`只能用一个模板参数，这个例子不就用了两个嘛。

2.2.3 判断两个类型是否可做加法运算

实现的思路仍然是使用`std::declval()`得到两个对象的右值引用，然后让它们“加”一下，看看“加”的表达式是否合法。

template<typename U, typename V, typename T = void> 
struct is_can_add : std::false_type  { };
 
template<typename U, typename V>
struct is_can_add<U, V, std::void_t< decltype(std::declval<U>() + std::declval<V>()) > 
                  > : std::true_type { };

3.std::void_t 与 std::enable_if

`std::enable_if<>` 可以用在函数返回值上，也可以用在函数参数或模板参数上，它的原理就是借助 `std::enable_if<>` 的失效条件产生错误的函数签名，然后利用 SFINAE 机制从函数候选集中移除替换失败的函数，从而达到选择特定的函数重载形式或类模板的实例化结果的目的，这是`std::enable_if<>`的使用特点。

`std::void_t<>`则可以用来判断一个类型的正确性或存在性，借助于`decltype` 和`std::declval()`，还可以用来判断一个表达式是否合法。如果存在性和合法性判断失败将导致`std::void_t<>`的定义失败，利用这一点配合 SFINAE 机制也可以实现在编译其的一些类型选择。

与传统的使用 SFINAE 机制的方法相比，`std::enable_if<>`和`std::void_t<>`具有更简洁的语义表达方式和更直观的语法形式，使用的方法也很方便。它们一直被认为是 C++ 20 的概念（concept）推出之前使用 SFINAE 机制的最佳方式。