Estoy tratando de deducir el tipo de plantilla subyacenteT de un tipoE = T<T2,T3>. Esto permitiría, por ejemplo, hacer que una plantilla funcione con pair_maker (const E y a) que se pueda usar con uno de varios tipos de contenedores similares. Código meta áspero:

template <typename T>
auto pairmaker(const E & a) -> PairContents<E,std::string>::type {
    ContainerPairMaker<E,std::string>::type output;
    ... some code ...
    return output;
}

PairContents<E,std::string>

transformaría el tipovector<int> dentrovector<pair(int,std::string)> owhatever<T1> dentrowhatever<pair(T1,std::string)>.

Otro ejemplo similar de disección de tipos es para std :: array (o contenedores similares) donde me gusta averiguar laenvase escriba para hacer una nueva matriz similar. Por ejemplo, para este tipo de funciones (este es el código de trabajo real ahora)

template <typename T > 
auto make_some3(const T & a) 
           -> std::array<typename T::value_type,10*std::tuple_size<T>::value>{   
   return std::array<typename T::value_type,10*std::tuple_size<T>::value>{} ;
}

Esto funciona bien, pero lo que busco es hacer que el uso explícito de 'std :: array' sea automático.

Para std :: array hay el rasgo tuple_size que ayuda, y se puede usar una cosa similar para encontrar eltype para cualquier segundo argumento, pero nuevamente no puedo pensar en nada para encontrar el tipo de contenedor.

Para resumir: qué tipo de maquinaria (si corresponde) puede usarse en casos como estos. Hasta qué punto es posible tratar con mezclas de argumentos de plantilla, argumentos de plantilla-plantilla, cualquier número de argumentos y argumentos de tipo desconocido de plantilla desconocida.