C++ `std::is_detected` 模式：优雅地检测类型特征是否存在

哈喽，各位好！今天咱们来聊聊C++里一个挺有意思的特性检测技巧，叫做std::is_detected模式。这玩意儿听起来高大上，实际上是为了解决一个很常见的问题：如何在编译期判断某个类型是否支持某个操作，或者是否定义了某个成员。

想象一下，你写了一个泛型函数，希望这个函数可以处理各种各样的类型。但是，不同的类型可能支持不同的操作。比如，有的类型有begin()和end()方法，可以被当成容器来迭代；有的类型可能重载了+运算符，可以进行加法运算。

如果你的泛型函数在处理不支持特定操作的类型时，直接调用这些操作，编译器就会报错。这可不是我们想看到的。我们希望的是，在编译期就能够判断类型是否支持某个操作，然后根据判断结果，选择不同的处理方式。

std::is_detected模式就是为了解决这个问题而生的。它允许我们在编译期“探测”类型是否具有某种特性，然后根据探测结果，编写更加灵活和健壮的泛型代码。

1. 问题的起源：SFINAE 和 decltype

要理解std::is_detected，我们首先要回顾一下两个C++的重要特性：SFINAE (Substitution Failure Is Not An Error) 和 decltype。

• SFINAE (Substitution Failure Is Not An Error)：

  简单来说，SFINAE的意思是，如果在模板参数推导或者模板实例化过程中，发生了错误（比如，试图访问一个不存在的成员），编译器不会立即报错，而是会尝试其他的模板重载或者特化。如果所有尝试都失败了，编译器才会报错。

  这个特性非常重要，因为它允许我们根据类型是否支持某个操作，来选择不同的模板。

• decltype：

  decltype是一个操作符，它可以推导出表达式的类型。比如，decltype(x + y)会推导出x + y这个表达式的类型。

  decltype在std::is_detected模式中扮演着重要的角色，因为它可以帮助我们“探测”类型是否支持某个操作。

2. std::is_detected 的基本原理

std::is_detected模式的核心思想是：

1. 定义一个“探测器”模板，这个模板使用decltype来尝试执行某个操作。
2. 如果这个操作能够成功执行，decltype就会推导出表达式的类型，探测器模板就会成功实例化。
3. 如果这个操作不能成功执行（比如，类型不支持这个操作），decltype就会导致编译错误，但是由于SFINAE的存在，编译器不会立即报错，而是会选择其他的模板重载或者特化。
4. 我们可以定义一个特化的模板，用来处理探测失败的情况。

下面是一个简单的std::is_detected的实现：

#include <iostream>
#include <type_traits>

template <typename T, template <typename> typename Op>
struct is_detected {
 private:
  template <typename U>
  static constexpr auto check(int) -> decltype(Op<U>::value, std::true_type{});

  template <typename U>
  static constexpr std::false_type check(...);

 public:
  static constexpr bool value = std::is_same_v<decltype(check<T>(0)), std::true_type>;
};

template <typename T, template <typename> typename Op>
inline constexpr bool is_detected_v = is_detected<T, Op>::value;

// Example usage: Detect if a type has a "value" member.
template <typename T>
struct has_value_member {
  using value = decltype(std::declval<T>().value); // Try to access T::value
};

struct A {
  int value = 10;
};

struct B {};

int main() {
  std::cout << std::boolalpha;
  std::cout << "A has value member: " << is_detected_v<A, has_value_member> << std::endl;
  std::cout << "B has value member: " << is_detected_v<B, has_value_member> << std::endl;

  return 0;
}

在这个例子中：

• is_detected是一个通用的模板，它接受一个类型T和一个模板Op作为参数。Op模板负责定义我们要探测的操作。
• has_value_member是一个模板，它使用decltype(std::declval<T>().value)来尝试访问类型T的value成员。如果T有value成员，decltype就会推导出value成员的类型，否则会导致编译错误。
• check函数使用了SFINAE来处理探测失败的情况。第一个check函数使用了decltype来尝试执行Op<U>::value，如果成功，就返回std::true_type。如果失败，编译器会选择第二个check函数，它返回std::false_type。
• is_detected::value是一个静态常量，它的值是true或者false，取决于check函数返回的是std::true_type还是std::false_type。

3. 使用 std::is_detected_v (C++17)

C++17 引入了 variable templates，允许我们使用一个变量来表示一个模板。这使得std::is_detected的使用更加方便。我们可以定义一个is_detected_v变量模板，如下所示：

template <typename T, template <typename> typename Op>
inline constexpr bool is_detected_v = is_detected<T, Op>::value;

有了is_detected_v，我们就可以直接使用is_detected_v<T, Op>来判断类型T是否支持操作Op，而不需要写is_detected<T, Op>::value这么长的代码了。

4. 探测不同的类型特征

std::is_detected模式可以用来探测各种各样的类型特征。下面是一些常见的例子：

• 探测类型是否具有某个成员函数：

  template <typename T>
  struct has_begin {
    using value = decltype(std::declval<T>().begin());
  };
  
  template <typename T>
  struct has_end {
    using value = decltype(std::declval<T>().end());
  };
  
  // Example usage:
  #include <vector>
  #include <list>
  
  int main() {
    std::cout << "std::vector has begin: " << is_detected_v<std::vector<int>, has_begin> << std::endl;
    std::cout << "std::list has begin: " << is_detected_v<std::list<int>, has_begin> << std::endl;
    std::cout << "int has begin: " << is_detected_v<int, has_begin> << std::endl;
  
    return 0;
  }

• 探测类型是否重载了某个运算符：

  template <typename T>
  struct has_plus {
    using value = decltype(std::declval<T>() + std::declval<T>());
  };
  
  // Example usage:
  #include <string>
  
  int main() {
    std::cout << "int has plus: " << is_detected_v<int, has_plus> << std::endl;
    std::cout << "std::string has plus: " << is_detected_v<std::string, has_plus> << std::endl;
  
    return 0;
  }

• 探测类型是否具有某个嵌套类型：

  template <typename T>
  struct has_value_type {
    using value = typename T::value_type;
  };
  
  // Example usage:
  #include <vector>
  
  int main() {
    std::cout << "std::vector has value_type: " << is_detected_v<std::vector<int>, has_value_type> << std::endl;
    std::cout << "int has value_type: " << is_detected_v<int, has_value_type> << std::endl;
  
    return 0;
  }

5. 更进一步：使用 std::void_t (C++17)

C++17 引入了 std::void_t，它可以简化std::is_detected的实现。std::void_t是一个模板，它接受任意数量的类型作为参数，然后返回void类型。它的主要作用是，可以让我们在decltype中忽略表达式的类型，只关心表达式是否有效。

下面是一个使用std::void_t的std::is_detected的实现：

#include <iostream>
#include <type_traits>

template <typename... Ts>
using void_t = std::void_t<Ts...>;

template <typename T, template <typename> typename Op, typename = void>
struct is_detected : std::false_type {};

template <typename T, template <typename> typename Op>
struct is_detected<T, Op, void_t<Op<T>>> : std::true_type {};

template <typename T, template <typename> typename Op>
inline constexpr bool is_detected_v = is_detected<T, Op>::value;

// Example usage: Detect if a type has a "value" member.
template <typename T>
using has_value_member = decltype(std::declval<T>().value); // Try to access T::value

struct A {
  int value = 10;
};

struct B {};

int main() {
  std::cout << std::boolalpha;
  std::cout << "A has value member: " << is_detected_v<A, has_value_member> << std::endl;
  std::cout << "B has value member: " << is_detected_v<B, has_value_member> << std::endl;

  return 0;
}

在这个例子中：

• 我们定义了一个主模板is_detected，它继承自std::false_type。这意味着，默认情况下，is_detected::value的值是false。
• 我们定义了一个特化模板is_detected<T, Op, void_t<Op<T>>>，它继承自std::true_type。这个特化模板只有在Op<T>有效的情况下才会被选择。
• void_t<Op<T>>的作用是，如果Op<T>有效，void_t<Op<T>>就会被替换为void类型，特化模板就会被选择，is_detected::value的值就会变成true。如果Op<T>无效，void_t<Op<T>>就会导致编译错误，SFINAE会阻止编译器报错，主模板仍然会被选择，is_detected::value的值仍然是false。
• 注意，这里has_value_member不再是一个struct，而是一个using alias。这是因为我们只需要知道decltype(std::declval<T>().value)是否有效，而不需要访问它的value成员了。

6. std::experimental::is_detected_exact

虽然std::is_detected很有用，但是它有一个缺点：它只能判断类型是否具有某个特性，而不能判断这个特性的类型是否符合预期。

比如，我们想判断类型T是否具有一个名为value的成员，并且这个成员的类型是int。使用std::is_detected，我们只能判断T是否具有value成员，而无法判断value成员的类型是否是int。

为了解决这个问题，C++标准库提供了一个名为std::experimental::is_detected_exact的特性检测工具。这个工具可以判断类型是否具有某个特性，并且这个特性的类型是否符合预期。由于它在std::experimental命名空间下，所以使用前需要包含<experimental/type_traits>头文件。

#include <iostream>
#include <type_traits>
#include <experimental/type_traits>

template <typename T>
using value_type_of = decltype(std::declval<T>().value);

template <typename T, typename ExpectedType>
using is_detected_exact = std::experimental::is_detected_exact<ExpectedType, value_type_of, T>;

struct A {
  int value = 10;
};

struct B {
  double value = 3.14;
};

struct C {};

int main() {
  std::cout << std::boolalpha;
  std::cout << "A's value is int: " << is_detected_exact<A, int>::value << std::endl;
  std::cout << "B's value is int: " << is_detected_exact<B, int>::value << std::endl;
  std::cout << "C's value is int: " << is_detected_exact<C, int>::value << std::endl; // Will be false because C has no value member

  return 0;
}

7. 总结

std::is_detected模式是一个强大的工具，它可以帮助我们编写更加灵活和健壮的泛型代码。通过使用std::is_detected，我们可以在编译期判断类型是否支持某个操作，然后根据判断结果，选择不同的处理方式。

下面是一个表格，总结了std::is_detected模式的优点和缺点：

优点	缺点
可以在编译期判断类型是否支持某个操作	实现起来稍微有点复杂
可以编写更加灵活和健壮的泛型代码	需要一定的C++模板基础
可以避免在运行时出现类型错误	只能判断类型是否具有某个特性，而不能判断这个特性的值是否符合预期 (可以使用std::experimental::is_detected_exact来解决这个问题)
可以提高代码的可读性和可维护性

希望今天的讲解对大家有所帮助！记住，std::is_detected只是C++模板元编程中的一个工具，还有很多其他的工具可以帮助我们编写更加强大的泛型代码。多多练习，才能真正掌握这些工具！