Dichiarare oggetto "contenitore" da modelli template classe e modelli variadic

Question

Devo dichiarare una classe in grado di memorizzare diversi tipi di contenitori. Sarebbe bello se potesse gestire std :: bitset e std :: array. Tuttavia, queste due classi richiedono un diverso argomento del template ... E 'possibile (e possibilmente, in che modo) usare classi template template e modelli variadic per dichiarare questo tipo di classe?

Esempio (ma sbagliato):

template<template <typename..., std::size_t> class Container, 
     std::size_t N, 
     typename... Args> 
class Base_Class 
{ 
    ... 
    Container<Args..., N/2> container; 
}; 

Il compilatore lamenta che N/2 non è un tipo. Ovviamente, sia per std :: array che per std :: bitset ho bisogno che la dimensione sia l'ultimo parametro del template ... È possibile codificare questa follia?

Grazie!

MODIFICA: Per quanto mi riguarda, il problema principale è che i modelli variadici possono essere espansi solo a destra, quindi il parametro variadic deve essere l'ultimo. Qualcuno sa se ci sono piani per consentire la seguente sintassi in C++ 17?

template<typename... Args, typename T> 
struct A 
{}; 

Answer 1

risposta di Anton può essere reso un po 'meno utilizzando i parametri del modello modello per le speciliasations di ResizedContainer specifici container:

namespace detail { 
    template<typename Container> 
    struct ResizedContainer; 

    template<template<typename,std::size_t> class Container, 
      typename T, std::size_t N> 
    struct ResizedContainer<Container<T,N>> { 
     using type = Container<T,N/2>; 
    }; 

    template<template<std::size_t> class Container, 
      std::size_t N> 
    struct ResizedContainer<Container<N>> { 
     using type = Container<N/2>; 
    }; 
} 

#include <array> 
#include <bitset> 

template<typename Container> 
class Base_Class { 
    typename detail::ResizedContainer<Container>::type container; 
}; 

int main() { 
    Base_Class<std::array<int,4>> a; 
    Base_Class<std::bitset<5>> b; 
} 

Answer 2

Forse qualcosa di simile:

namespace detail { 
    template<typename Container> 
    struct ResizedContainer; 

    template<typename T, size_t N> 
    struct ResizedContainer<std::array<T, N>> { 
     using type = std::array<T, N/2>; 
    }; 

    template<size_t N> 
    struct ResizedContainer<std::bitset<N>> { 
     using type = std::bitset<N/2>; 
    }; 
} 

template<typename Container> 
class Base_Class { 
    typename detail::ResizedContainer<Container>::type container; 
}; 

int main() { 
    Base_Class<std::array<int, 4>> a; 
    Base_Class<std::bitset<5>> b; 
}