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

Question

背景:我创建了以下类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;
};

问题:我的问题是如何将variadic约束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);

我在这篇文章中看到了一个可能的解决方案:https://stackoverflow.com/a/11414631,它定义了一个通用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(通过引用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()...}
{}

我担心如果我使用像std :: is_base_of这样的谓词,我将为每组参数获得构造函数的不同实例化,这可能会增加编译代码的大小......

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()...}
{}

Also, you do not have to worry about a ton of specializations anymore.