检查所有可变模板参数的特征

Question

背景： 我创建了以下 class C，其构造函数应采用 N 类型的变量 B& :

class A;
class B
{
    A* getA();
};

template<size_t N>
class C
{
public:
    template<typename... Args>
    inline C(Args&... args) :
        member{args.getA()...}
    {}
private:
    std::array<A*, N> member;
};

问题： 我的问题是如何将可变参数 Args 约束为所有 B 类型？

我的部分解决方案： 我想定义一个谓词：

template <typename T, size_t N, typename... Args>
struct is_range_of :
    std::true_type // if Args is N copies of T
    std::false_type // otherwise
{};

并相应地重新定义我的构造函数：

template <typename... Args,
          typename = typename std::enable_if<is_range_of_<B, N, Args...>::value>::type
         >
inline C(Args&... args);

我已经看到关于这个 post 的可能解决方案：，它定义了一个通用的 check_all 谓词：

template <template<typename> class Trait, typename... Args>
struct check_all :
    std::false_type
{};

template <template<typename> class Trait>
struct check_all<Trait> :
    std::true_type
{};

template <template<typename> class Trait, typename T, typename... Args>
struct check_all<Trait, T, Args...> :
    std::integral_constant<bool, Trait<T>::value && check_all<Trait, Args...>::value>
{};

所以，我可以这样写：

template <typename T, size_t N, typename... Args>
struct is_range_of :
    std::integral_constant<bool,
        sizeof...(Args) == N &&
        check_all<Trait, Args...>::value
    >
{};

问题 1： 我不知道如何定义 Trait，因为我需要以某种方式将 std::is_same 与 B 绑定作为第一个参数。在我的例子中，有没有办法使用泛型 check_all，或者 C++ 的当前语法是否不兼容？

问题 2： 我的构造函数也应该接受 B 的派生 classes（通过对 B 的引用），是吗？模板参数推导的问题？我担心如果我使用像 std::is_base_of 这样的谓词，我会为每组参数得到不同的构造函数实例，这可能会增加编译代码的大小...

编辑： 例如，我有 B1 和 B2 继承自 B，我调用 C<2>(b1, b1) 和C<2>(b1, b2) 在我的代码中，它会创建两个实例（C<2>::C<B1, B1> 和 C<2>::C<B1, B2>）吗？我只想要 C<2>::C<B, B>.

的实例

Answer 1

定义all_true为

template <bool...> struct bool_pack;

template <bool... v>
using all_true = std::is_same<bool_pack<true, v...>, bool_pack<v..., true>>;

并将构造函数重写为

// Check convertibility to B&; also, use the fact that getA() is non-const
template<typename... Args,
       typename = std::enable_if_t<all_true<std::is_convertible<Args&, B&>{}...>>
C(Args&... args) :
    member{args.getA()...}
{}

或者，在 C++17 下，

template<typename... Args,
       typename = std::enable_if_t<(std::is_convertible_v<Args&, B&> && ...)>>
C(Args&... args) :
    member{args.getA()...}
{}

I am afraid that if I use a predicate like std::is_base_of, I will get a different instantiation of the constructor for each set of parameters, which could increase compiled code size...

enable_if_t<…> 总是会产生 void 类型（只给出一个模板参数），所以这不可能是 is_base_of 的错。但是，当 Args 具有不同的类型时，即参数的类型不同，随后将实例化不同的特化。不过，我希望编译器能在这里进行优化。

如果您希望构造函数精确地接受 N 个参数，您可以使用更简单的方法。定义

template <std::size_t, typename T>
using ignore_val = T;

现在部分特化 C 为

// Unused primary template
template <size_t N, typename=std::make_index_sequence<N>> class C;
// Partial specialization
template <size_t N, std::size_t... indices>
class C<N, std::index_sequence<indices...>>
{ /* … */ };

部分特化中构造函数的定义现在变得微不足道

C(ignore_val<indices, B&>... args) :
    member{args.getA()...}
{}

此外，您不必再担心大量的专业化。

Answer 2

namespace detail {
    template <bool...> struct bool_pack;
    template <bool... v>
    using all_true = std::is_same<bool_pack<true, v...>, bool_pack<v..., true>>;
    template<class X> constexpr X implicit_cast(std::enable_if_t<true, X> x) {return x;}
};

implicit_cast 也在 Boost 中，bool_pack 从偷来的。

// Only callable with static argument-types `B&`, uses SFINAE
template<typename... ARGS, typename = std::enable_if_t<
    detail::all_true<std::is_same<B, ARGS>...>>>
C(ARGS&... args) noexcept : member{args.getA()...} {}

选项一，如果它是隐式可转换的就足够了

template<typename... ARGS, typename = std::enable_if_t<
    detail::all_true<!std::is_same<
    decltype(detail::implicit_cast<B&>(std::declval<ARGS&>())), ARGS&>...>>
C(ARGS&... args) noexcept(noexcept(implicit_cast<B&>(args)...))
    : C(implicit_cast<B&>(args)...) {}

选项二，仅当它们公开派生自 B 并且明确可转换时：

// Otherwise, convert to base and delegate
template<typename... ARGS, typename = decltype(
    detail::implicit_cast<B*>(std::declval<ARGS*>())..., void())>
C(ARGS&... args) noexcept : C(implicit_cast<B&>(args)...) {}

未命名的 ctor-template-argument-type 在任何成功的替换中都是 void。

检查所有可变模板参数的特征

Check traits for all variadic template arguments

c++

typetraits

variadic-templates

c++11

c++14