C ++检查构造函数是否包含给定类型的参数 [英] C++ check whether constructor contains a parameter of given type

问题描述

使用 std :: is_constructible ，可以询问特定构造函数存在的给定类型：

With std::is_constructible one can question some given type for the presence of a certain constructor:

struct A {};
struct B
{
     explicit B(int, A, double) {}
};

int main()
{
    std::cout<<std::is_constructible<B,int,A,double>::value<<std::endl; //prints true
}

假设不知道类型 B 。还有一种方法来检查在 B 中是否存在包含类型 A 的构造函数，而不考虑其他参数？ （ - 或者，已经足够，在第n个位置包含 A 类型？）

Suppose one does not know type B. Is there also a way to check whether there exists a constructor in B which contains type A, regardless of the other parameters? (--or, already sufficient, which contains type A in the n-th position?)

给定一个非 - 显式的构造函数，我想出了一个解决方法，通过使用一个类型可以隐式转换为任何东西：

Given a non-explicit constructor, I figured out a workaround by using a type which can be implicitly converted to anything:

struct convert_to_anything
{
    template<typename T>
    operator T() const
    {
        return T{};    
    }
};

int main()
{
    std::cout<<std::is_constructible<B, convert_to_anything, A, convert_to_anything>::value<<std::endl;
}

（其实，对我来说意外的是，我根据经验发现它似乎工作以及当 B ...的构造函数中添加显式 ...但我认为这会阻止转换？）

(Actually, and unexpected to me, I found empirically that it seems to work as well when explicit is added to the constructor of B ... whereas I thought it would prevent from conversions?)

仍然，使用这个解决方法，我必须测试所有可能的参数数量。在第一个位置说出 A ：

Still, with this workaround I would have to test all possible numbers of parameters. Say for an A in the first position:

std::is_constructible<B, A>::value
|| std::is_constructible<B, A, convert_to_anything>::value
|| std::is_constructible<B, A, convert_to_anything, convert_to_anything>::value
//... and so on up to a chosen maximum size.

这似乎有点不满意。你有什么更好的解决方法？

That seems a bit unsatisfying. Do you have any better workarounds?

推荐答案

不，实际上没有其他方法来完成。根据您的建议，可以使用编译时元编程来手动展开排列。我相信下面的通用实现是尽可能好的可能。请参阅 has_constructor_taking 别名模板及其在代码底部的用法。

No, there is essentially no other way to accomplish this. As you suggest, one can use compile-time metaprogramming to manually unroll the permutations. I believe the generic implementation below is about as good as it can possibly be. See the has_constructor_taking alias template and its usage at the bottom of the code.

下面的代码使用 template_worm 技巧我在这里描述这里，这是一个更丰富的实现您的 convert_to_anything 。该代码适用于Clang和GCC的最新版本。

The code below uses the template_worm technique I describe here, which is a more fleshed-out implementation of your convert_to_anything. The code works on recent versions of both Clang and GCC.

#include <utility>
#include <type_traits>
#include <tuple>

namespace detail {

    //template_worm CANNOT be used in evaluated contexts
    struct template_worm {

        template<typename T>
        operator T& () const;

        template<typename T>
        operator T && () const;

        template_worm() = default;

        template<typename... T>
        template_worm(T&&...);

        template_worm operator+() const;
        template_worm operator-() const;
        template_worm operator*() const;
        template_worm operator&() const;
        template_worm operator!() const;
        template_worm operator~() const;
        template_worm operator()(...) const;
    };

#define TEMPLATE_WORM_BINARY_OPERATOR(...)                                 \
                                                                           \
    template<typename T>                                                   \
    constexpr inline auto                                                  \
    __VA_ARGS__ (template_worm, T&&) -> template_worm {                    \
        return template_worm{};                                            \
    }                                                                      \
                                                                           \
    template<typename T>                                                   \
    constexpr inline auto                                                  \
    __VA_ARGS__ (T&&, template_worm) -> template_worm {                    \
        return template_worm{};                                            \
    }                                                                      \
                                                                           \
    constexpr inline auto                                                  \
    __VA_ARGS__ (template_worm, template_worm) -> template_worm {          \
        return template_worm{};                                            \
    }                                                                      \
    /**/

    TEMPLATE_WORM_BINARY_OPERATOR(operator+)
    TEMPLATE_WORM_BINARY_OPERATOR(operator-)
    TEMPLATE_WORM_BINARY_OPERATOR(operator/)
    TEMPLATE_WORM_BINARY_OPERATOR(operator*)
    TEMPLATE_WORM_BINARY_OPERATOR(operator==)
    TEMPLATE_WORM_BINARY_OPERATOR(operator!=)
    TEMPLATE_WORM_BINARY_OPERATOR(operator&&)
    TEMPLATE_WORM_BINARY_OPERATOR(operator||)
    TEMPLATE_WORM_BINARY_OPERATOR(operator|)
    TEMPLATE_WORM_BINARY_OPERATOR(operator&)
    TEMPLATE_WORM_BINARY_OPERATOR(operator%)
    TEMPLATE_WORM_BINARY_OPERATOR(operator,)
    TEMPLATE_WORM_BINARY_OPERATOR(operator<<)
    TEMPLATE_WORM_BINARY_OPERATOR(operator>>)
    TEMPLATE_WORM_BINARY_OPERATOR(operator<)
    TEMPLATE_WORM_BINARY_OPERATOR(operator>)

    template<typename T>
    struct success : std::true_type {};

    template<typename T, typename... Args>
    struct try_construct {
        static constexpr bool value = std::is_constructible<T, Args...>::value;
    };

    template<typename T>
    struct try_construct<T, void> {

        template<typename U>
        static auto test(int) ->
            success<decltype(U())>;

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

        static constexpr const bool value = decltype(test<T>(0))::value;
    };

    template<typename T, typename ArgTuple, typename MappedSeq>
    struct try_construct_helper;

    template<typename T, typename ArgTuple, std::size_t... I>
    struct try_construct_helper<T, ArgTuple, std::index_sequence<I...>> {
        using type = try_construct<T, typename std::tuple_element<I, ArgTuple>::type...>;
    };

    struct sentinel {};

    template<typename Target>
    using arg_map = std::tuple<Target, template_worm const &>;

    constexpr const std::size_t MappedTargetIndex = 0;
    constexpr const std::size_t MappedWormIndex = 1;

    template<std::size_t>
    using worm_index = std::integral_constant<std::size_t, MappedWormIndex>;

    template<typename SeqLeft, typename SeqRight>
    struct map_indices;

    template<std::size_t... Left, std::size_t... Right>
    struct map_indices<std::index_sequence<Left...>, std::index_sequence<Right...>> {

        using type = std::index_sequence<
            worm_index<Left>::value...,
            MappedTargetIndex,
            worm_index<Right>::value...
        >;
    };

    template<std::size_t... Right>
    struct map_indices<sentinel, std::index_sequence<Right...>> {
        using type = std::index_sequence<0, worm_index<Right>::value...>;
    };

    template<std::size_t... Left>
    struct map_indices<std::index_sequence<Left...>, sentinel> {
        using type = std::index_sequence<worm_index<Left>::value..., 0>;
    };

    template<>
    struct map_indices<sentinel, sentinel> {
        using type = std::index_sequence<0>;
    };

    template<std::size_t IncrementBy, typename Seq>
    struct increment_seq;

    template<std::size_t IncrementBy, std::size_t... I>
    struct increment_seq<IncrementBy, std::index_sequence<I...>> {
        using type = std::index_sequence<(I + IncrementBy)...>;
    };

    // Checks the U constructor by passing TargetArg in every argument slot recursively
    template<typename U, typename TargetArg, std::size_t TargetIndex, std::size_t Max, typename SeqOrSentinel>
    struct try_constructors;

    template<typename U, typename TargetArg, std::size_t TargetIndex, std::size_t Max>
    struct try_constructors<U, TargetArg, TargetIndex, Max, sentinel> {
        static constexpr const bool value = false;
    };

    template<typename U, typename TargetArg, std::size_t TargetIndex, std::size_t Max, std::size_t... I>
    struct try_constructors<U, TargetArg, TargetIndex, Max, std::index_sequence<I...>> {

        using next = typename std::conditional<
            sizeof...(I)+1 <= Max,
            std::make_index_sequence<sizeof...(I)+1>,
            sentinel
        >::type;

        using args = arg_map<TargetArg>;

        using left_seq = typename std::conditional<
            TargetIndex == 0,
            sentinel,
            std::make_index_sequence<TargetIndex>
        >::type;

        using right_seq_detail = typename increment_seq<
            TargetIndex,
            std::make_index_sequence<sizeof...(I)-TargetIndex>
        >::type;

        using right_seq = typename std::conditional<
            TargetIndex == (sizeof...(I)),
            sentinel,
            right_seq_detail
        >::type;

        using mapped_seq = typename map_indices<left_seq, right_seq>::type;

        static constexpr const bool value = std::disjunction<
            typename try_construct_helper<U, args, mapped_seq>::type,
            try_constructors<U, TargetArg, TargetIndex, Max, next>
        >::value;
    };

    // unrolls the constructor attempts using the argument counts in the SearchSeq range
    template<typename T, typename TargetArg, typename SearchSeq>
    struct try_constructors_outer;

    template<typename T, typename TargetArg, std::size_t... TargetIndices>
    struct try_constructors_outer<T, TargetArg, std::index_sequence<TargetIndices...>> {

        static constexpr const bool value = std::disjunction<
            try_constructors<
                T,
                TargetArg,
                TargetIndices,
                sizeof...(TargetIndices),
                std::make_index_sequence<TargetIndices>
            >...
        >::value;
    };

    template<typename T, std::size_t... TargetIndices>
    struct try_constructors_outer<T, void, std::index_sequence<TargetIndices...>> {
        static constexpr const bool value = try_construct<T, void>::value;
    };
}

// Here you go.
template<typename TargetArg, typename T, std::size_t SearchLimit = 4>
using has_constructor_taking = std::integral_constant<bool,
    detail::try_constructors_outer<
        T,
        TargetArg,
        std::make_index_sequence<SearchLimit>
    >::value
>;

struct A {};

struct B {
    B(int, A, double) {}
};

struct C {
    C() = delete;
    C(C const &) = delete;
};

static_assert(has_constructor_taking<A, B>::value, "");
static_assert(has_constructor_taking<int, B>::value, "");
static_assert(has_constructor_taking<double, B>::value, "");
static_assert(!has_constructor_taking<C, B>::value, "");
static_assert(!has_constructor_taking<const char*, B>::value, "");

static_assert(has_constructor_taking<void, A>::value, "");
static_assert(has_constructor_taking<A const &, A>::value, "");

static_assert(!has_constructor_taking<void, C>::value, "");
static_assert(!has_constructor_taking<C const &, C>::value, "");

int main() {}

这篇关于C ++检查构造函数是否包含给定类型的参数的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！