Question

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

using namespace std;

template<typename Coll>
class has_push_back
{
    using coll_type = decay_t<Coll>;
    using True = char(&)[1];
    using False = char(&)[2];

    template<typename U, void(U::*)(const typename U::value_type&)>
    struct SFINAE {};

    template<typename T>
    static True Test(SFINAE<T, &T::push_back>*);

    template<typename T>
    static False Test(...);

public:
    enum { value = sizeof(Test<coll_type>(nullptr)) == sizeof(True) };
};

class MyColl : public vector<int> {};

int main()
{
    cout << has_push_back<vector<int>>::value << endl;
    cout << has_push_back<MyColl>::value << endl;
}

上面的程序将输出：

1
0

如果继承了函数has_push_back，则表明模板push_back无效。

有没有办法让它继续工作？

Answer 1

此处a solution使用void_t，这是C ++ 17中的标准配置，并且还附带了其他实用程序，例如Library Fundamentals v2 TS中的is_detected_exact，占用最多has_push_back的工作：

template<typename... Ts>
using void_t = void;

template<typename T>
using push_back_test = decltype(std::declval<T>().push_back(std::declval<typename T::const_reference>()));

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

template<typename T>
struct has_push_back<T, void_t<push_back_test<T>>> : std::is_same<push_back_test<T>, void> {};

或with future utilities：

template<typename T>
using push_back_test = decltype(std::declval<T>().push_back(std::declval<typename T::const_reference>()));

template<typename T>
using has_push_back = std::experimental::is_detected_exact<void, push_back_test, T>;

如果您想详细了解void_t，建议您查看Walter Brown's CppCon 2015 talks。

Answer 2

template<typename Coll>
struct has_push_back {
    template<
        typename T,
        typename = decltype(
            std::declval<T&>().push_back(std::declval<typename T::value_type>())
        )
    >
    static std::true_type Test(int);

    template<typename T>
    static std::false_type Test(long);

    using type = decltype(Test<Coll>(0));
    static constexpr bool value = type::value;
};

Online Demo

Answer 3

根据this回答，您的代码可能如下所示：

#include <type_traits>

// Primary template with a static assertion
// for a meaningful error message
// if it ever gets instantiated.
// We could leave it undefined if we didn't care.

template<typename, typename T>
struct has_push_back {
    static_assert(
        std::integral_constant<T, false>::value,
        "Second template parameter needs to be of function type.");
};

// specialization that does the checking

template<typename C, typename Ret, typename... Args>
struct has_push_back<C, Ret(Args...)> {
private:
    template<typename T>
    static constexpr auto check(T*)
    -> typename
        std::is_same<
            decltype( std::declval<T>().push_back( std::declval<Args>()... ) ),
            Ret    // ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
        >::type;  // attempt to call it and see if the return type is correct

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

    typedef decltype(check<C>(0)) type;

public:
    static constexpr bool value = type::value;
};

@jork的所有学分

您可能已使用this回答的代码，但它不使用继承的函数。

Answer 4

为了完整起见，我想发布另一种前面未提及的方法这是基于函数的定义和别名声明它遵循一个最小的工作示例：

#include <vector>
#include <type_traits>
#include<utility>

using namespace std;

template<typename T, typename... U>
constexpr auto f(int)
-> std::conditional_t<false, decltype(std::declval<T>().push_back(std::declval<U>()...)), std::true_type>;

template<typename, typename...>
constexpr std::false_type f(char);

template<typename T, typename... U>
using has_push_back = decltype(f<T, U...>(0));

class MyColl : public vector<int> {};

int main() {
    static_assert(has_push_back<vector<int>, int>::value, "!");
    static_assert(has_push_back<MyColl, int>::value, "!");
}

如何检查类在编译时是否具有继承函数？

4 个答案: