如何在检测习语中要求精确的函数签名?

时间：2023-05-24

本文介绍了如何在检测习语中要求精确的函数签名?的处理方法，对大家解决问题具有一定的参考价值，需要的朋友们下面随着小编来一起学习吧！

问题描述

限时送ChatGPT账号..

假设我有一个 T 类型，我想检测它是否有一个下标运算符，我可以用另一个类型 Index 调用它.以下示例工作正常:

Let's suppose I have a type T and I want to detect whether it has a subscript operator which I can call with with another type Index. The following example works just fine:

#include <type_traits>
#include <vector>

template < typename T, typename Index >
using subscript_t = decltype(std::declval<T>()[std::declval<Index>()]);

int main()
{
    using a = subscript_t< std::vector<int>, size_t >;
    using b = subscript_t< std::vector<int>, int    >;
}

但是，我希望当且仅当函数签名完全匹配时才能检测到该函数.在上面的例子中，我想要语句 subscript_t<std::vector<int>, int >; 抛出类似no可靠重载运算符[]的错误，因为std::vector的下标运算符的签名 是

However, I want the function to be detected if and only if the function signature matches exactly. In the example above I would like the statement subscript_t< std::vector<int>, int >; to throw an error like no viable overloaded operator[], because the signature of the subscript operator for std::vector is

std::vector<T, std::allocator<T>>::operator[](size_type pos);

其中 size_type 在 GCC 中是 unsigned long.如何避免从 int 到 size_t 的隐式转换发生?

where size_type in GCC is unsigned long. How can I avoid the implicit conversion from int to size_t to take place?

推荐答案

With is_detected，你可以这样做:

With is_detected, you may do:

template <typename T, typename Ret, typename Index>
using subscript_t = std::integral_constant<Ret (T::*) (Index), & T::operator[]>;


template <typename T, typename Ret, typename Index>
using has_subscript = is_detected<subscript_t, T, Ret, Index>;

static_assert(has_subscript<std::vector<int>, int&, std::size_t>::value, "!");
static_assert(!has_subscript<std::vector<int>, int&, int>::value, "!");

演示

我在 SO 文档中写了这个:

I wrote this in SO Documentation:

概括type_trait的创建:基于SFINAE有实验特征detected_or、detected_t、is_detected.

To generalize type_trait creation:based on SFINAE there are experimental traits detected_or, detected_t, is_detected.

带模板参数typename Default，template Op 和 typename ... Args:

is_detected:std::true_type 或 std::false_type 的别名，取决于 Op
detected_t:Op 或 nonesuch 的别名，取决于 Op.
detected_or:value_t 是 is_detected 和 type 是的结构的别名Op 或 Default 取决于 Op

的有效性



is_detected: alias of std::true_type or std::false_type depending of the validity of Op<Args...>
detected_t: alias of Op<Args...> or nonesuch depending of validity of Op<Args...>.
detected_or: alias of a struct with value_t which is is_detected, and type which is Op<Args...> or Default depending of validity of Op<Args...>

可以使用 std::void_t 为 SFINAE 实现如下:
which can be implemented using std::void_t for SFINAE as following:
namespace detail {
    template <class Default, class AlwaysVoid,
              template<class...> class Op, class... Args>
    struct detector
    {
        using value_t = std::false_type;
        using type = Default;
    };

    template <class Default, template<class...> class Op, class... Args>
    struct detector<Default, std::void_t<Op<Args...>>, Op, Args...>
    {
        using value_t = std::true_type;
        using type = Op<Args...>;
    };

} // namespace detail

// special type to indicate detection failure
struct nonesuch {
    nonesuch() = delete;
    ~nonesuch() = delete;
    nonesuch(nonesuch const&) = delete;
    void operator=(nonesuch const&) = delete;
};

template <template<class...> class Op, class... Args>
using is_detected =
    typename detail::detector<nonesuch, void, Op, Args...>::value_t;

template <template<class...> class Op, class... Args>
using detected_t = typename detail::detector<nonesuch, void, Op, Args...>::type;

template <class Default, template<class...> class Op, class... Args>
using detected_or = detail::detector<Default, void, Op, Args...>;

然后可以简单地实现检测方法存在的特征:
Traits to detect presence of method can then be simply implemented:
template <typename T, typename ...Ts>
using foo_type = decltype(std::declval<T>().foo(std::declval<Ts>()...));

struct C1 {};

struct C2 {
    int foo(char) const;
};

template <typename T>
using has_foo_char = is_detected<foo_type, T, char>;

static_assert(!has_foo_char<C1>::value, "Unexpected");
static_assert(has_foo_char<C2>::value, "Unexpected");

static_assert(std::is_same<int, detected_t<foo_type, C2, char>>::value,
              "Unexpected");

static_assert(std::is_same<void, // Default
                           detected_or<void, foo_type, C1, char>>::value,
              "Unexpected");
static_assert(std::is_same<int, detected_or<void, foo_type, C2, char>>::value,
              "Unexpected");


                        这篇关于如何在检测习语中要求精确的函数签名?的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持html5模板网！



上一篇：是 std::array<T, S>如果 T 是 POD 就保证是 POD? 
下一篇：为什么 C++ 模板定义需要在头文件中? 

 
相关文章
为什么两个函数的地址相同?Why do two functions have the same address?(为什么两个函数的地址相同?)
为什么 std::function 的初始化程序必须是可复制构Why the initializer of std::function has to be CopyConstructible?(为什么 std::function 的初始化程序必须是可复制构造的?)
混合模板与多态性mixing templates with polymorphism(混合模板与多态性)
我什么时候应该使用关键字“typename"?使用模When should I use the keyword quot;typenamequot; when using templates(我什么时候应该使用关键字“typename?使用模板时)
依赖名称解析命名空间 std/标准库Dependent name resolution amp; namespace std / Standard Library(依赖名称解析命名空间 std/标准库)
gcc 可以编译可变参数模板，而 clang 不能gcc can compile a variadic template while clang cannot(gcc 可以编译可变参数模板，而 clang 不能)



最新文章

为什么“A&lt;0&gt;=0"中的模板id由于大于
如何测试类 B 是否派生自类的模板族
删除“通用"的专用模板函数案例无法使用 
我能在模板参数中声明一个 constexpr lambda 吗?
“永久"标准::设置
你如何将结构模板标记为朋友?
类模板中的模板构造函数 - 如何为第二个参数显
我可以将 C++17 无捕获 lambda constexpr 转换运算符的
为什么具有“相同签名"的模板和非模板函数
来自元组的构造函数参数