Digamos que você tenha uma classe cujo trabalho é conectar-se a um servidor remoto. Eu quero abstrair esta classe para fornecer duas versões, uma que se conecta pelo UDP e a outra pelo TCP. Eu quero construir o código de tempo de execução mais enxuto possível e, em vez de usar o polimorfismo, estou considerando modelos. Aqui está o que estou imaginando, mas não tenho certeza de que é a melhor maneira de fazer isso:

class udp {};
class tcp {};

template<class T,typename X>
class service
{
private:
  // Make this private so this non specialized version can't be used
   service();
};

template<typename X>
class service<udp, X>
{
private:
   udp _udp;
   X _x;
};

template<typename X>
class service<tcp, X>
{
private:
   tcp _tcp;
   X _x;
};

Portanto, o benefício final é que a generosidade de T ainda está disponível, mas o código muito diferente necessário para configurar uma conexão UDP ou TCP foi especializado. Suponho que você possa colocar os dois em uma classe ou fornecer outra classe que adira a alguma interface virtual pura para configurar a conexão de rede, como IConnectionManager.

Mas isso deixa o problema do código para o T genérico, que agora precisa ser escrito e mantido nas duas versões especializadas, onde são basicamente os mesmos. Qual a melhor forma de resolver isso? Tenho a sensação de que estou fazendo tudo errado.