Verifique os traços para todos os argumentos de modelos variáveis

Fundo : Eu criei a seguinte classeC, cujo construtor deve levarN variáveis do tipoB& :

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;
};

Problema: meu problema é como restringir o variadicArgs ser todo do tipoB ?

Minha solução parcial: Eu queria definir um predicado como:

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
{};

E redefina meu construtor de acordo:

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

Eu vi uma possível solução neste post:https://stackoverflow.com/a/11414631, que define um genéricocheck_all predicado:

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>
{};

Então, eu poderia escrever algo como:

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

Questão 1 : Eu não sei como definir oTrait, porque eu preciso de alguma forma ligarstd::is_same comB como primeiro argumento. Existe algum meio de usar o genéricocheck_all no meu caso, ou a gramática atual do C ++ é incompatível?

Questão 2 : Meu construtor também deve aceitar classes derivadas deB (através de uma referência aB), é um problema para dedução de argumento de modelo? Receio que, se eu usar um predicado comostd::is_base_of, Receberei uma instanciação diferente do construtor para cada conjunto de parâmetros, o que poderia aumentar o tamanho do código compilado ...

Editar: Por exemplo, eu tenhoB1 eB2 que herda deB, Eu chamoC<2>(b1, b1) eC<2>(b1, b2) no meu código, ele criará duas instâncias (deC<2>::C<B1, B1> eC<2>::C<B1, B2>)? Eu quero apenas instâncias deC<2>::C<B, B>.

questionAnswers(2)

yourAnswerToTheQuestion