C++ 如何在检测习惯用法中要求精确的函数签名？

假设我有一个类型

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

其中，GCC中的

size\u type

为

无符号长型

。如何避免发生从

int

到

size\t

的隐式转换？

您可以这样做：

template <typename Index, typename ClassType, typename ReturnType>
constexpr bool arg_t(ReturnType (ClassType::*)(Index))
{
    return true;
}

template <typename T, typename Index>
struct subscript_t
{
    static_assert(arg_t<Index>(&T::operator[]));
};

另一种方法，用于确定确切的错误消息：

template <typename ClassType, typename ReturnType, typename ArgType>
constexpr ArgType arg_t(ReturnType (ClassType::*)(ArgType))
{
    return {};
}

template <typename T, typename Index>
struct subscript_t
{
    using Actual = decltype(arg_t(&T::operator[]));
    static_assert(std::is_same<Index, Actual>::value, "oops");
};

模板
constexpr ArgType arg_t（返回类型（类类型：：*）（ArgType））
{
返回{}；
}
模板
结构下标
{
使用Actual=decltype（arg_t（&t:：operator[]）；
静态断言（std:：is_same:：value，“oops”）；
};

使用，您可以执行以下操作：

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

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

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

模板
使用foo_type=decltype（std:：declval（）.foo（std:：declval（）…）；
结构C1{}；
结构C2{
int foo（char）const；
};
模板
检测到使用has\u foo\u char=；
静态断言（！has_foo_char:：value，“意外”）；
静态_断言（具有_foo_char:：value，“意外”）；
静态断言（std:：is_same:：value，
“意外”）；
静态断言（std:：is_same:：value，
“意外”）；
静态断言（std:：is_same:：value，
“意外”）；

我要说的是，它不是C++11/14的一部分，也不是C++17的一部分；它还没有被合并。它可能会也可能不会进入C++2a。

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

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