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

#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 viable overloaded operator[] 的错误, 因为 std::vector 的下标运算符的签名是

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

哪里size_type在 GCC 中是 unsigned long .如何避免 int 的隐式转换至 size_t发生？

最佳答案

与 is_detected ，你可以这样做:

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, "!");

Demo

我在 SO 文档中写了这个:

is_detected

泛化type_trait的创建:基于SFINAE 有实验性状detected_or , detected_t , is_detected .

带模板参数typename Default , template <typename...> Op和 typename ... Args :

• is_detected : std::true_type 的别名或 std::false_type取决于 Op<Args...> 的有效性
• detected_t : Op<Args...> 的别名或 nonesuch取决于 Op<Args...> 的有效性.
• detected_or : 带有 value_t 的结构的别名这是is_detected , 和 type这是Op<Args...>或 Default取决于 Op<Args...> 的有效性

可以使用 std::void_t 实现SFINAE 如下:

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...>;

然后可以简单地实现用于检测方法存在的特征:

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");

关于c++ - 如何在检测习语中要求精确的函数签名？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/45249985/