[英]C++ check whether constructor contains a parameter of given type
With std::is_constructible
one can question some given type for the presence of a certain constructor: 使用std::is_constructible
可以向某些给定类型询问是否存在某个构造函数:
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
}
Suppose one does not know type B
. 假设一个人不知道B
型。 Is there also a way to check whether there exists a constructor in B
which contains type A
, regardless of the other parameters? 是否还有一种方法可以检查B
是否存在包含类型A
的构造函数,而不管其他参数是什么? (--or, already sufficient, which contains type A
in the n-th position?) ( - 或者,已经足够了,在第n个位置包含A
型?)
Given a non- explicit
constructor, I figured out a workaround by using a type which can be implicitly converted to anything: 给定一个非explicit
构造函数,我通过使用可以隐式转换为任何东西的类型找出了一种解决方法:
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;
}
(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?) (实际上,对我来说意外的是,我在经验上发现当将explicit
添加到B
的构造函数时它似乎也能正常工作......而我认为它会阻止转换?)
Still, with this workaround I would have to test all possible numbers of parameters. 但是,通过这种解决方法,我将不得不测试所有可能的参数数量。 Say for an A
in the first position: 在第一个位置说A
:
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? 你有更好的解决方法吗?
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. 请参阅代码底部的has_constructor_taking
别名模板及其用法。
The code below uses the template_worm
technique I describe here , which is a more fleshed-out implementation of your convert_to_anything
. 下面的代码使用我在这里描述的template_worm
技术,这是convert_to_anything
一个更加丰富的实现。 The code works on recent versions of both Clang and GCC. 该代码适用于Clang和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() {}
声明:本站的技术帖子网页,遵循CC BY-SA 4.0协议,如果您需要转载,请注明本站网址或者原文地址。任何问题请咨询:yoyou2525@163.com.