Conversão implícita ao sobrecarregar operadores para classes de modelo
Gostaria de saber por que a conversão implícita de tipo não funciona com sobrecarga de operador externo nos modelos de classe. Aqui está a versão funcional e sem modelo:
class foo
{
public:
foo() = default;
foo(int that)
{}
foo& operator +=(foo rhs)
{
return *this;
}
};
foo operator +(foo lhs, foo rhs)
{
lhs += rhs;
return lhs;
}
Como esperado, as seguintes linhas são compiladas corretamente:
foo f, g;
f = f + g; // OK
f += 5; // OK
f = f + 5; // OK
f = 5 + f; // OK
Por outro lado, quando a classefoo
é declarado como um modelo simples como este:
template< typename T >
class foo
{
public:
foo() = default;
foo(int that)
{}
foo& operator +=(foo rhs)
{
return *this;
}
};
template< typename T >
foo< T > operator +(foo< T > lhs, foo< T > rhs)
{
lhs += rhs;
return lhs;
}
As seguintes linhas são compiladas com erros:
foo< int > f, g;
f = f + g; // OK
f += 5; // OK
f = f + 5; // Error (no match for operator+)
f = 5 + f; // Error (no match for operator+)
Gostaria de entender por que o compilador (GCC 4.6.2) não pode executar a conversão implícita de tipo usando o construtor de conversão para a versão do modelo da classe. Esse é o comportamento esperado? Além de criar manualmente todas as sobrecargas necessárias, existe alguma solução alternativa para isso?