使用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
}
假设一个人不知道类型B。是否还有一种方法可以检查B中是否存在包含类型A的构造函数，而不管其他参数是什么？ （ - 或者，已经足够了，在第n个位置包含类型A？）
鉴于非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;
}
（实际上，我意外地发现，当explicit添加到B的构造函数中时，我发现它似乎也能正常工作......而我认为它会阻止转换？ ）
但是，通过这种解决方法，我将不得不测试所有可能的参数数量。在第一个位置说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.
这似乎有点令人不满意。你有更好的解决方法吗？
答案 0 :(得分：5)
不，基本上没有其他方法可以实现这一目标。正如您所建议的那样，可以使用编译时元编程来手动展开排列。我相信下面的通用实现尽可能好。请参阅代码底部的has_constructor_taking别名模板及其用法。
以下代码使用我所描述的template_worm技术here，这是convert_to_anything更加丰富的实现。该代码适用于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() {}