C++ `std::is_detected` 模式：优雅地检测成员函数是否存在 - 智猿学院-前后端，数据库，人工智能，云计算等领域前沿技术讲座

好的，各位观众老爷，欢迎来到“C++黑魔法揭秘”系列讲座。今天我们要聊的是一个非常实用，但又有点晦涩的C++技巧：std::is_detected模式。

开场白：C++的痛点与优雅的解决方案

在C++的世界里，我们经常会遇到这样的问题：我们需要判断一个类是否拥有某个特定的成员函数，或者某个特定的类型定义。比如，我想知道一个类有没有 size() 方法，或者有没有定义 value_type。在以前，这可不是一件容易的事情，需要用到一些奇技淫巧，代码写出来就像巫术一样，让人看了头皮发麻。

但是，C++20 引入了 std::is_detected，它就像一位优雅的绅士，轻轻挥一挥魔杖，就能帮你解决这个问题，让你的代码瞬间变得高大上。

什么是std::is_detected？

std::is_detected 是一个类型特征（Type Trait），它的作用是检测某个表达式是否有效。如果表达式有效，std::is_detected 的 value 成员就是 true，否则就是 false。

你可以把它想象成一个侦探，专门负责调查某个表达式是否存在，并告诉你调查结果。

std::is_detected 的基本用法

先来看一个最简单的例子：

#include <iostream>
#include <type_traits>

template<typename T>
using size_method_t = decltype(std::declval<T>().size());

template<typename T>
using has_size_method = std::is_detected<size_method_t, T>;

struct HasSize {
    size_t size() const { return 0; }
};

struct NoSize {};

int main() {
    std::cout << std::boolalpha;
    std::cout << "HasSize has size(): " << has_size_method<HasSize>::value << std::endl; // true
    std::cout << "NoSize has size(): " << has_size_method<NoSize>::value << std::endl;   // false
    return 0;
}

这段代码做了什么？

定义了一个别名模板 size_method_t： 这个模板尝试调用类型 T 的 size() 方法。 std::declval<T>() 用于创建一个类型 T 的对象，但不会实际构造它（因为 std::declval 只能在未求值的上下文中使用）。 decltype 用于获取表达式 std::declval<T>().size() 的类型。如果类型 T 没有 size() 方法，这个别名模板就会编译失败。
定义了一个类型特征 has_size_method： std::is_detected<size_method_t, T> 使用 size_method_t 别名模板来检测类型 T 是否有 size() 方法。如果 size_method_t<T> 有效（即类型 T 有 size() 方法），has_size_method<T>::value 就是 true，否则就是 false。
定义了两个结构体 HasSize 和 NoSize： HasSize 有 size() 方法，NoSize 没有。
在 main 函数中测试： 使用 has_size_method 来判断 HasSize 和 NoSize 是否有 size() 方法，并打印结果。

深入理解 std::is_detected

std::is_detected 的核心在于SFINAE（Substitution Failure Is Not An Error，替换失败不是错误）。简单来说，SFINAE 指的是，如果在模板参数替换的过程中，某个模板实例化导致了编译错误，编译器不会立即报错，而是会尝试其他的模板实例化。

std::is_detected 正是利用了 SFINAE 的特性。当我们使用 std::is_detected<size_method_t, T> 时，如果类型 T 没有 size() 方法，size_method_t<T> 就会编译失败。但是，由于 SFINAE 的存在，编译器不会立即报错，而是会选择其他的模板实例化，最终导致 std::is_detected<size_method_t, T>::value 为 false。

std::is_detected 的更多用法

除了检测成员函数是否存在，std::is_detected 还可以用于检测其他类型的表达式是否有效，比如：

检测成员变量是否存在：

#include <iostream>
#include <type_traits>

template<typename T>
using member_x_t = decltype(std::declval<T>().x);

template<typename T>
using has_member_x = std::is_detected<member_x_t, T>;

struct HasX {
    int x;
};

struct NoX {};

int main() {
    std::cout << std::boolalpha;
    std::cout << "HasX has member x: " << has_member_x<HasX>::value << std::endl; // true
    std::cout << "NoX has member x: " << has_member_x<NoX>::value << std::endl;   // false
    return 0;
}

检测类型定义是否存在：

#include <iostream>
#include <type_traits>

template<typename T>
using value_type_t = typename T::value_type;

template<typename T>
using has_value_type = std::is_detected<value_type_t, T>;

struct HasValueType {
    using value_type = int;
};

struct NoValueType {};

int main() {
    std::cout << std::boolalpha;
    std::cout << "HasValueType has value_type: " << has_value_type<HasValueType>::value << std::endl; // true
    std::cout << "NoValueType has value_type: " << has_value_type<NoValueType>::value << std::endl;   // false
    return 0;
}

检测某个表达式是否可以编译：

#include <iostream>
#include <type_traits>

template<typename T>
using can_add_t = decltype(std::declval<T>() + std::declval<T>());

template<typename T>
using can_add = std::is_detected<can_add_t, T>;

struct Addable {
    Addable operator+(const Addable&) const { return {}; }
};

struct NotAddable {};

int main() {
    std::cout << std::boolalpha;
    std::cout << "Addable can be added: " << can_add<Addable>::value << std::endl; // true
    std::cout << "NotAddable can be added: " << can_add<NotAddable>::value << std::endl;   // false
    return 0;
}

std::is_detected_exact：更精确的检测

有时候，我们不仅仅想知道某个表达式是否有效，还想知道它的类型是否符合我们的预期。这时候，就可以使用 std::is_detected_exact。

std::is_detected_exact<Expected, Functor, Args...> 的作用是，检测 Functor<Args...> 的结果是否可以转换为 Expected 类型。如果可以，std::is_detected_exact 的 value 成员就是 true，否则就是 false。

#include <iostream>
#include <type_traits>

template<typename T>
using size_method_t = decltype(std::declval<T>().size());

template<typename T>
using has_size_method_and_returns_size_t = std::is_detected_exact<size_t, size_method_t, T>;

struct HasSize {
    size_t size() const { return 0; }
};

struct HasSizeInt {
    int size() const { return 0; }
};

struct NoSize {};

int main() {
    std::cout << std::boolalpha;
    std::cout << "HasSize has size() and returns size_t: " << has_size_method_and_returns_size_t<HasSize>::value << std::endl;       // true
    std::cout << "HasSizeInt has size() and returns size_t: " << has_size_method_and_returns_size_t<HasSizeInt>::value << std::endl;    // false
    std::cout << "NoSize has size() and returns size_t: " << has_size_method_and_returns_size_t<NoSize>::value << std::endl;         // false
    return 0;
}

在这个例子中，has_size_method_and_returns_size_t 不仅检测类型 T 是否有 size() 方法，还检测 size() 方法的返回值是否可以转换为 size_t 类型。

std::is_detected_convertible：检测是否可以隐式转换

有时候，我们想知道某个表达式的结果是否可以隐式转换为某个类型。 std::is_detected_convertible 就是用来做这个的。

#include <iostream>
#include <type_traits>

template<typename T>
using size_method_t = decltype(std::declval<T>().size());

template<typename T>
using has_size_method_and_convertible_to_size_t = std::is_detected_convertible<size_t, size_method_t, T>;

struct HasSize {
    size_t size() const { return 0; }
};

struct HasSizeInt {
    int size() const { return 0; }
};

struct NoSize {};

int main() {
    std::cout << std::boolalpha;
    std::cout << "HasSize has size() and convertible to size_t: " << has_size_method_and_convertible_to_size_t<HasSize>::value << std::endl;       // true
    std::cout << "HasSizeInt has size() and convertible to size_t: " << has_size_method_and_convertible_to_size_t<HasSizeInt>::value << std::endl;    // true
    std::cout << "NoSize has size() and convertible to size_t: " << has_size_method_and_convertible_to_size_t<NoSize>::value << std::endl;         // false
    return 0;
}

std::is_detected_convertible 与 std::is_detected_exact 的区别在于，std::is_detected_convertible 允许隐式类型转换，而 std::is_detected_exact 则要求类型完全匹配。

使用 std::is_detected 的优势

代码更清晰、更易读： 相比于以前的 SFINAE 技巧，std::is_detected 的代码更加简洁明了，更容易理解。
更安全： std::is_detected 可以避免一些潜在的编译错误，提高代码的健壮性。
更通用： std::is_detected 可以用于检测各种类型的表达式，适用范围更广。

一个更复杂的例子：检测迭代器类型

让我们来一个更实际的例子：检测一个类是否提供了迭代器类型（iterator、const_iterator），以及 begin() 和 end() 方法。

#include <iostream>
#include <type_traits>
#include <vector>
#include <list>

// Helper templates to detect iterator types
template <typename T>
using iterator_t = typename T::iterator;

template <typename T>
using const_iterator_t = typename T::const_iterator;

// Helper templates to detect begin() and end() methods
template <typename T>
using begin_t = decltype(std::declval<T>().begin());

template <typename T>
using end_t = decltype(std::declval<T>().end());

// Type traits to check for the existence of iterators and begin/end
template <typename T>
using has_iterator = std::is_detected<iterator_t, T>;

template <typename T>
using has_const_iterator = std::is_detected<const_iterator_t, T>;

template <typename T>
using has_begin = std::is_detected<begin_t, T>;

template <typename T>
using has_end = std::is_detected<end_t, T>;

// A class that provides iterators
struct MyContainer {
    using iterator = int*;
    using const_iterator = const int*;

    iterator begin() { return data; }
    iterator end() { return data + size; }

    const_iterator begin() const { return data; }
    const_iterator end() const { return data + size; }

    int data[5];
    size_t size = 5;
};

// A class that doesn't provide iterators
struct MyNonContainer {};

int main() {
    std::cout << std::boolalpha;

    std::cout << "MyContainer has iterator: " << has_iterator<MyContainer>::value << std::endl;          // true
    std::cout << "MyContainer has const_iterator: " << has_const_iterator<MyContainer>::value << std::endl;    // true
    std::cout << "MyContainer has begin(): " << has_begin<MyContainer>::value << std::endl;              // true
    std::cout << "MyContainer has end(): " << has_end<MyContainer>::value << std::endl;                  // true

    std::cout << "MyNonContainer has iterator: " << has_iterator<MyNonContainer>::value << std::endl;       // false
    std::cout << "MyNonContainer has const_iterator: " << has_const_iterator<MyNonContainer>::value << std::endl; // false
    std::cout << "MyNonContainer has begin(): " << has_begin<MyNonContainer>::value << std::endl;           // false
    std::cout << "MyNonContainer has end(): " << has_end<MyNonContainer>::value << std::endl;               // false

    std::cout << "std::vector<int> has iterator: " << has_iterator<std::vector<int>>::value << std::endl;      // true
    std::cout << "std::vector<int> has const_iterator: " << has_const_iterator<std::vector<int>>::value << std::endl; // true
    std::cout << "std::vector<int> has begin(): " << has_begin<std::vector<int>>::value << std::endl;          // true
    std::cout << "std::vector<int> has end(): " << has_end<std::vector<int>>::value << std::endl;              // true

     std::cout << "std::list<int> has iterator: " << has_iterator<std::list<int>>::value << std::endl;      // true
    std::cout << "std::list<int> has const_iterator: " << has_const_iterator<std::list<int>>::value << std::endl; // true
    std::cout << "std::list<int> has begin(): " << has_begin<std::list<int>>::value << std::endl;          // true
    std::cout << "std::list<int> has end(): " << has_end<std::list<int>>::value << std::endl;              // true

    return 0;
}

这个例子展示了如何使用 std::is_detected 来检测一个类是否满足迭代器的要求。这在编写泛型算法时非常有用，可以根据类型是否支持迭代器来选择不同的实现。

std::void_t：简化代码的利器

在实际使用中，我们经常需要定义一些辅助的别名模板，比如上面的 size_method_t、member_x_t 等。为了避免代码冗余，可以使用 std::void_t 来简化代码。

std::void_t<T...> 的作用是，无论 T... 是什么类型，它都返回 void。它的主要用途是在 SFINAE 上下文中，用于简化类型特征的定义。

让我们用 std::void_t 来改写一下检测 size() 方法的例子：

#include <iostream>
#include <type_traits>

template<typename T, typename = std::void_t<>>
struct has_size_method : std::false_type {};

template<typename T>
struct has_size_method<T, std::void_t<decltype(std::declval<T>().size())>> : std::true_type {};

struct HasSize {
    size_t size() const { return 0; }
};

struct NoSize {};

int main() {
    std::cout << std::boolalpha;
    std::cout << "HasSize has size(): " << has_size_method<HasSize>::value << std::endl; // true
    std::cout << "NoSize has size(): " << has_size_method<NoSize>::value << std::endl;   // false
    return 0;
}

这段代码使用了一个模板特化技巧。首先，定义了一个通用的 has_size_method，它继承自 std::false_type，表示默认情况下，类型 T 没有 size() 方法。然后，定义了一个模板特化，当 std::declval<T>().size() 有效时，这个特化会被选择，并且 has_size_method 继承自 std::true_type，表示类型 T 有 size() 方法。

std::void_t 在这里的作用是，如果 std::declval<T>().size() 无效，std::void_t<decltype(std::declval<T>().size())> 就会导致模板参数替换失败，从而选择通用的 has_size_method。

总结

std::is_detected 是一个非常强大的工具，可以帮助我们编写更清晰、更安全、更通用的 C++ 代码。掌握 std::is_detected 及其相关技巧，可以让你在 C++ 的世界里更加游刃有余。

一些使用建议

尽量使用 std::is_detected 代替手写的 SFINAE 代码： std::is_detected 的代码更加简洁明了，更容易理解和维护。
使用 std::void_t 简化类型特征的定义： std::void_t 可以避免代码冗余，提高代码的可读性。
根据实际需求选择合适的 std::is_detected 变体： 如果只需要检测表达式是否有效，使用 std::is_detected；如果需要检测表达式的类型是否符合预期，使用 std::is_detected_exact；如果需要检测表达式的结果是否可以隐式转换为某个类型，使用 std::is_detected_convertible。
合理使用 SFINAE： SFINAE 是一个强大的工具，但也容易出错。在使用 SFINAE 时，一定要仔细考虑各种情况，避免出现意外的编译错误。

最后的彩蛋：requires 子句与 std::is_detected 的结合

C++20 引入了 requires 子句，可以用来约束模板参数。 requires 子句可以与 std::is_detected 结合使用，使代码更加清晰和易于理解。

#include <iostream>
#include <type_traits>

template<typename T>
concept HasSize = requires(T t) {
    t.size();
};

struct HasSizeImpl {
    size_t size() const { return 0; }
};

struct NoSizeImpl {};

template<typename T>
    requires HasSize<T>
size_t getSize(const T& t) {
    return t.size();
}

template<typename T>
    requires (!HasSize<T>)
size_t getSize(const T& t) {
    std::cout << "Type doesn't have size() method." << std::endl;
    return 0;
}

int main() {
    HasSizeImpl hasSize;
    NoSizeImpl noSize;

    std::cout << "Size of hasSize: " << getSize(hasSize) << std::endl;
    std::cout << "Size of noSize: " << getSize(noSize) << std::endl;

    return 0;
}

在这个例子中，我们使用 requires 子句定义了一个概念 HasSize，它要求类型 T 必须有 size() 方法。然后，我们定义了一个函数 getSize，它接受一个类型为 T 的参数，并且使用 requires 子句来约束模板参数 T。如果类型 T 满足 HasSize 概念，就调用 t.size() 方法；否则，就打印一条错误信息。

这种方式比直接使用 std::enable_if 更加清晰和易于理解。

好了，今天的讲座就到这里。感谢各位观众老爷的观看，希望大家能够掌握 std::is_detected 这个强大的工具，编写出更加优雅的 C++ 代码。下次再见！

发表回复 取消回复

发表回复取消回复