Eu estou tentando deduzir o tipo de modelo subjacenteT de um tipoE = T<T2,T3>. Isto permitiria, por exemplo, fazer uma função de template par_maker (const E & a) que pode ser usada com um dos vários tipos similares de containers. Meta código:

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>

transformaria o tipovector<int> para dentrovector<pair(int,std::string)> ouwhatever<T1> para dentrowhatever<pair(T1,std::string)>.

Outro exemplo semelhante de dissecação de tipo é para std :: array (ou containers similares) onde eu gosto de descobrirrecipiente digite para criar um novo array similar. Por exemplo, para este tipo de funções (este é o código de trabalho atual agora)

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

Isso funciona bem, mas o que eu estou procurando é tornar o uso explícito de 'std :: array' automático.

Para o std :: array, há o traço tuple_size que ajuda, e uma coisa semelhante pode ser usada para encontrar otype para qualquer segundo argumento, mas novamente não consigo pensar em nada para encontrar o tipo de contêiner.

Para resumir: que tipo de maquinário (se houver) pode ser usado para casos como esses. Até que ponto é possível lidar com misturas de argumentos de modelo, argumentos modelo de modelo, qualquer número de argumentos e argumentos não-modelo de tipos desconhecidos.