std::is_detected 和 Detection Idoms
本文锁定于 C++17 范围内谈实作。
关于 std::is_detected
确切地说，是指 std::experimental::is_detected, std::experimental::detected_t, std::experimental::detected_or。因为尚未被纳入正式库，所以在现行的编译器中，它们通常至少需要 C++17 规范指定，并包含专门的头文件
但是编译器的支持也是参差不齐。所以我们一般都采用自定义的版本，同样需要 C++17 规范（如果需要更低规范适配版本，请自行搜索），但表现能力更可靠、更可预测：
#if !defined(__TRAITS_VOIT_T_DEFINED)
#define __TRAITS_VOIT_T_DEFINED
// ------------------------- void_t
namespace cmdr::traits {
#if (__cplusplus > 201402L)
using std::void_t; // C++17 or later
#else
// template
// using void_t = void;
template
struct make_void { using type = void; };
template
using void_t = typename make_void::type;
#endif
} // namespace cmdr::traits
#endif // __TRAITS_VOIT_T_DEFINED
#if !defined(__TRAITS_IS_DETECTED_DEFINED)
#define __TRAITS_IS_DETECTED_DEFINED
// ------------------------- is_detected
namespace cmdr::traits {
template class, class = void_t<>>
struct detect : std::false_type {};
template class Op>
struct detect>> : std::true_type {};
template class Op, class... Args>
struct detector {
using value_t = std::false_type;
using type = T;
};
template class Op, class... Args>
struct detector>, Op, Args...> {
using value_t = std::true_type;
using type = Op;
};
struct nonesuch final {
nonesuch() = delete;
~nonesuch() = delete;
nonesuch(const nonesuch &) = delete;
void operator=(const nonesuch &) = delete;
};
template class Op, class... Args>
using detected_or = detector;
template class Op, class... Args>
using detected_or_t = typename detected_or::type;
template class Op, class... Args>
using detected = detected_or;
template class Op, class... Args>
using detected_t = typename detected::type;
/**
* @brief another std::is_detected
* @details For example:
* @code{c++}
* template<typename T>
* using copy_assign_op = decltype(std::declval<T &>() = std::declval<const T &>());
*
* template<typename T>
* using is_copy_assignable = is_detected<copy_assign_op, T>;
*
* template<typename T>
* constexpr bool is_copy_assignable_v = is_copy_assignable<T>::value;
* @endcode
*/
template class Op, class... Args>
using is_detected = typename detected::value_t;
template class Op, class... Args>
constexpr bool is_detected_v = is_detected::value;
template class Op, class... Args>
using is_detected_exact = std::is_same>;
template class Op, class... Args>
using is_detected_convertible = std::is_convertible, To>;
} // namespace cmdr::traits
#endif // __TRAITS_IS_DETECTED_DEFINED 当然，也涉及到 std::void_t，也是 C++17 才进入标准库的。但你可以自己声明，如同上面的 VOID_T 部分一样。
但 is_detected 的低版本兼容部分我们就放弃了，太长了，我也不想加多单元测试负担。
它的使用方式是这样的：
#include
#include
template
using copy_assign_op = decltype(std::declval() = std::declval());
template
using is_copy_assignable = is_detected;
template
constexpr bool is_copy_assignable_v = is_copy_assignable::value;
struct foo {};
struct bar {
bar &operator=(const bar &) = delete;
};
int main() {
static_assert(is_copy_assignable_v, "foo is copy assignable");
static_assert(!is_copy_assignable_v, "bar is not copy assignable");
return 0;
} 可以看到这是一种典型的 detection idioms 惯用法，能够在编译期测试出一个类型具有什么特性。例如 is_chrono_duration, is_iterator, is_integer 等等，在标准库中有大量预定义的检测专用的 traits。
但在实际生活中我们通常还需要定义自己的。例如在我们的 undo-cxx 中就有一组：
namespace undo_cxx {
template typename RefCmdT,
typename Cmd>
class undoable_cmd_system_t {
public:
~undoable_cmd_system_t() = default;
using StateT = State;
using ContextT = Context;
using CmdT = Cmd;
using CmdSP = std::shared_ptr;
using Memento = typename CmdT::Memento;
using MementoPtr = typename std::unique_ptr;
using Container = std::list;
using Iterator = typename Container::iterator;
using size_type = typename Container::size_type;
template
struct has_save_state : std::false_type {};
template
struct has_save_state().save_state()))> : std::true_type {};
template
struct has_undo : std::false_type {};
template
struct has_undo().undo()))> : std::true_type {};
template
struct has_redo : std::false_type {};
template
struct has_redo().redo()))> : std::true_type {};
template
struct has_can_be_memento : std::false_type {};
template
struct has_can_be_memento().can_be_memento()))> : std::true_type {};
public:
// ...
void undo(CmdSP &undo_cmd) {
if constexpr (has_undo::value) {
// needs void undo_cmd::undo(sender, ctx, delta)
undo_cmd->undo(undo_cmd, _ctx, 1);
return;
}
if (undo_one()) {
// undo ok
}
}
// ...
};
} 你可能注意到这个例子中压根没有用到 is_detected。
确实如此，Detection Idioms 包含一系列手法，并不是一定要用到哪一个工具模板，重点还是在于目标，它们都是为了在编译期测试出某个类型的特性，以便针对性地进行特化、偏特化，或者用于完成其他任务。
所以这是个巨大无比的话题。
Detection Idioms
在提案 [WG21 N4436 - Proposing Standard Library Support for the C++ Detection Idiom [pdf]](http://open-std.org/JTC1/SC22...) 中，检测惯用法被称作 Detection Idiom。这个提案是在 C++20 中被加入，一部分原因在于它可以成为一个补全性的方案，另一方面则是因为 Concepts 一直提了十几年却都没有定论。当然最后我们知道了，去年 C++20 定案之后 concepts 终于被加入了。
但是可以预见的是，未来直到 2023 年，工程当中使用 concepts 的可能性还是基本上为零。事实上 2023 年 C++17 如能成为工程应用主流的话就阿弥陀佛了，多数工程还是 C++11 的，而且那些遗留项目连 C++11 都不用呢。
作为一个提案的代表，Detection Idiom 是一个专有名词。但检测惯用法，却是早已有之。或者说，traits 本来就是干这个的。在本文中的检测惯用法，会包含类型测试与约束，以及函数签名检测等等检测方法。
在 C++11 之后，借助于 SFINAE 我们有几种选择来完成类型约束与选择：特化方式，添加 enable_if 测试的特化方式，借助于 is_detected 的约束力。
普通的特化方式
模板参数的特化能力，对于一般情况的约束就是足够的：
template
bool max(T l, T r) { return l > r ? l : r; }
bool max(bool l, bool r) { return false; }
bool max(float l, float r) {
return (l+0.000005f > r) ? l : (r+0.000005f>l) ? r : IS_NAN;
} 上面的例子没有实际用处，只是用来展示特化的直接使用效果。
对于简单的类型来说，这种特化能力就已经足够了。不过遇到复杂的类型，特别是复合类型它的能力就比较短板了。
所以这种情况下我们需要借助于 enable_if 来进行约束。
std::enable_if 方式
std::enable_if 可能的实现方法
std::enable_if 的实现方法可以比较简单：
template
struct enable_if {};
template
struct enable_if {
using type = T;
}; 约束返回类型
对于函数返回类型来说，用法略有不同：
#include
#include
class foo;
class bar;
template
struct is_bar {
template
typename std::enable_if::value, bool>::type check() { return true; }
template
typename std::enable_if::value, bool>::type check() { return false; }
};
int main() {
is_bar foo_is_bar;
is_bar bar_is_bar;
if (!foo_is_bar.check() && bar_is_bar.check())
std::cout << "It works!" << std::endl;
return 0;
} 这是测试类型并返回 bool 的用例，也是较为典型的如何编写 traits 的用例。
不过为了真正说明函数返回类型模板化，还是要下面这个例子：
#include
#include
namespace AAA {
template
class Y {
public:
template
typename std::enable_if::value || std::is_same::value, Q>::type foo() {
return 11;
}
template
typename std::enable_if::value && !std::is_same::value, Q>::type foo() {
return 7;
}
};
} // namespace
int main(){
#define TestQ(typ) std::cout << "T foo() : " << (AAA::Y{}).foo() << '\n'
TestQ(short);
TestQ(int);
TestQ(long);
TestQ(bool);
TestQ(float);
TestQ(double);
} 输出为：
T foo() : 7
T foo() : 7
T foo() : 7
T foo() : 1
T foo() : 11
T foo() : 11这是一个实用化的用例，可以直接检测 double 或者 float 类型。
在 traits 中使用
测试一个模板中是否有名为 value 的类型定义：
template
struct has_typed_value;
template
struct has_typed_value::type> {
static constexpr bool value = T::value;
};
template
inline constexpr bool has_typed_value_v = has_typed_value::value;
static_assert(has_typed_value>::value, "std::is_same::value is valid");
static_assert(has_typed_value_v>, "std::is_same::value is valid"); 类似地：
template struct has_typed_type;
template
struct has_typed_type::type> {
static constexpr bool value = T::type;
};
template
inline constexpr bool has_typed_type_v = has_typed_type::value; 使用 conjuction
C++17 之后就可以直接使用 std::conjuction，它可以用于组合一组 detectors。
这里只给出一个 sample 片段：
template
using is_regular = std::conjunction,
std::is_copy_constructible,
supports_equality,
supports_inequality, //assume impl
supports_less_than>; //ditto 更多的
检测成员函数存在性
declval 方式
这个用例比较独立自主，什么都自己来，自己定义了 void_t，自己定义了名为 supports_foo 的 traits，目的是为了检测类型 T 是不是有 T::get_foo() 函数签名的存在。最后，calculate_foo_factor() 的特化目的就显而易见，无需解释了。
template
using void_t = void;
template
struct supports_foo : std::false_type{};
template
struct supports_foo().get_foo())>>
: std::true_type{};
template ::value>* = nullptr>
auto calculate_foo_factor (const T& t) {
return t.get_foo();
}
template ::value>* = nullptr>
int calculate_foo_factor (const T& t) {
// insert generic calculation here
return 42;
} 它采用了 declval 的伪造实例的技术，对此可以参考我们的 std::declval 和 decltype 一文。
Is_detected 方式
改用 is_detected 方式：
template
using to_string_t = decltype(std::declval().to_string());
template
constexpr bool has_to_string = is_detected_v;
struct AA {
std::string to_string() const { return ""; }
};
struct BB{};
static_assert(has_to_string, "");
static_assert(!has_to_string, ""); 这个没什么好说的，你可以用 std::experimental::is_detected，也可以使用我们前文中定义的 is_detected 工具。
作为一个补充
在没有 std::enable_if 的时候，需要借助于 struct char[] 方式，这种技巧被称作 Member Detector，是 C++11 之前的经典惯用法：
template
class DetectX
{
struct Fallback { int X; }; // add member name "X"
struct Derived : T, Fallback { };
template struct Check;
typedef char ArrayOfOne[1]; // typedef for an array of size one.
typedef char ArrayOfTwo[2]; // typedef for an array of size two.
template
static ArrayOfOne & func(Check *);
template
static ArrayOfTwo & func(...);
public:
typedef DetectX type;
enum { value = sizeof(func(0)) == 2 };
}; 而且还有配套的宏定义 GENERATE_HAS_MEMBER(member) ，所以在应用代码中只需要：
GENERATE_HAS_MEMBER(att) // Creates 'has_member_att'.
GENERATE_HAS_MEMBER(func) // Creates 'has_member_func'.
std::cout << std::boolalpha
<< "\n" "'att' in 'C' : "
<< has_member_att::value // -like interface.
<< "\n" "'func' in 'C' : "
<< has_member_func() // Implicitly convertible to 'bool'.
<< "\n"; 也是很疯狂。
进一步延伸
上一节提供的技术，仅仅对函数签名中的函数名本身进行检测。有时候，可能我们会在想对形参表或者返回类型做检测并约束。有可能吗？
确实是有的。
抽出函数返回类型
return_type_of_t 可以抽出函数的返回类型：
namespace AA1 {
template
using return_type_of_t =
typename decltype(std::function{std::declval()})::result_type;
int foo(int a, int b, int c, int d) {
return 1;
}
auto bar = [](){ return 1; };
struct baz_ {
double operator()(){ return 0; }
} baz;
void test_aa1() {
using ReturnTypeOfFoo = return_type_of_t;
using ReturnTypeOfBar = return_type_of_t;
using ReturnTypeOfBaz = return_type_of_t;
// ...
}
} 在这个基础上你就可以运用 enable_if 或者 is_detected 了。具体检测略略略……
检测函数形参表
至于形参表的检测问题，有点而麻烦，而且这一话题也很大，方向较多，所以我暂且给出一个方向供你参考，其他方向也就是万变不离其宗了。
bar_t 可以以 variadic 参数的方式罗列出类型表，并用来检测类型 T 是不是有一个函数 bar() 而且还有相应的形参表：
template
using bar_t = std::conditional_t<
true,
decltype(std::declval().bar(std::declval()...)),
std::integral_constant<
decltype(std::declval().bar(std::declval()...)) (T::*)(Arguments...),
&T::bar>>;
struct foo1 {
int const &bar(int &&) {
static int vv_{0};
return vv_;
}
};
static_assert(dp::traits::is_detected_v, "not detected"); 暂时我没有想法将它通用化，所以你需要具体情况具体拷贝和修改。
谁要是有改进版，不妨通知我。
检测 begin() 存在性并调用它
前文对成员函数存在性已经介绍过了，这里是一个实用的片段：检测成员函数存在与否，存在的话就调用它，否则的话调用我们的备用实现方案：
// test for `any begin() const`
template
using begin_op = decltype(std::declval().begin());
struct A_Container {
template
void invoke_begin(T const& t){
if constexpr(std::experimental::is_detected_v){
t.begin();
}else{
my_begin(); // begin() not exists!!
}
}
iterator my_begin() { ... }
}; 为什么不直接使用 SFINAE 技术呢？
因为 SFINAE 技术能够让我们做出 invoke_begin 的特化版本，但这有可能阻碍了我们的进一步拓展性。SFINAE 仅能在类型不匹配时起作用，但采用 begin_op 的方式我们可以：针对返回类型，针对形参表，针对 const or not，等等。
检测 emplace(Args &&...)
这要用到我们前面的 bar_t 技法：
template
using emplace_variadic_t = std::conditional_t<
true,
decltype(std::declval().emplace(std::declval()...)),
std::integral_constant<
decltype(std::declval().emplace(std::declval()...)) (T::*)(Arguments...),
&T::emplace>>;
/**
* @brief test member function `emplace()` with variadic params
* @tparam T
* @tparam Arguments
* @details For example:
* @code{c++}
* using C = std::list<int>;
* static_assert(has_emplace_variadic_v<C, C::const_iterator, int &&>);
* @endcode
*/
template
constexpr bool has_emplace_variadic_v = is_detected_v;
namespace detail {
using C = std::list;
static_assert(has_emplace_variadic_v);
} // namespace detail More...
在 cmdr-cxx 中有一组 detection traits，是用于检测标准库容器函数签名的。在 undo-cxx 中的 undoable_cmd_system_t 中我们运用了检测函数名存在性并调用它的技法。
关于 _t 和 _v
在标准库和标准化推行中，_t 和 _v 后缀隐含着直接提供 ::type 或者 ::value 成员的意思。
但这并不影响我（们）惯于使用 _t 表示一个模板类。
在一个模板类被用做基础类、被当成工具类使用时，我（们）喜欢为其增加 _t 后缀。
Refs
- [WG21 N4436 - Proposing Standard Library Support for the C++ Detection Idiom [pdf]](http://open-std.org/JTC1/SC22...) - Walter E. Brown 計劃在C++標準庫中加入 Detection 慣用法
- WG21 N4502: PDF - Proposing Standard Library Support for the C++ Detection Idiom, v2
- std::experimental::is_detected, std::experimental::detected_t, std::experimental::detected_or - cppreference.com
- std::void_t - cppreference.com
- std::enable_if - cppreference.com
- Detection Idiom - A Stopgap for Concepts
后记
检测惯用法实在是太大了，本文只是导引，将基本工具提供出来。后续未来应该会继续就此问题介绍我的经验。