Retorno tipo de polimorfismo em linguagens C-like

Question

Por que não vemos C-como idiomas que permitem chamáveis ??com polimorfismo no tipo de retorno? Eu podia ver como o tipo de inferência adicional seria um obstáculo, mas temos muitas línguas com sistemas de inferência de tipos de pleno direito (que trabalham para diferentes níveis de "trabalho").

Editar: Por tipo de retorno polimorfismo Quero dizer sobrecarregar a assinatura função só no tipo de retorno. Por exemplo, C ++ e Java permitem apenas a sobrecarga no tipo dos parâmetros formais, não no tipo de retorno.

Answer 1

Se por "retorno tipo de polimorfismo" Você quer dizer sobrecarga com base no tipo valor de retorno, eu não tenho certeza sobre outras línguas, mas para C ++ aqui está a resposta (praticamente da boca do cavalo):

tipos de retorno função não entram em jogo na resolução de sobrecarga, simplesmente porque Stroustrup (eu assumo com a entrada de outros arquitetos C ++) queria resolução de sobrecarga para ser 'contexto independente'. Veja 7.4.1 - "Sobrecarga e tipo de retorno" do "C ++ Programming Language, Third Edition".

A razão é manter a resolução para um operador ou função individual chamada independente do contexto.

Eles queriam que ele seja baseado apenas em como a sobrecarga foi chamado - não como o resultado foi utilizado (se ele foi usado em tudo). Na verdade, muitas funções são chamadas sem usar o resultado ou o resultado seria usado como parte de uma expressão maior. Um fator que eu tenho certeza que entrou em jogo quando decidiu este era que, se o tipo de retorno foi parte da resolução que haveria muitas chamadas para funções sobrecarregadas que precisam ser resolvidos com regras complexas ou teria que ter o lance compilador um erro que a chamada era ambígua.

E, Deus sabe, a resolução de sobrecarga C ++ é suficiente complexo, tal como está ...

Answer 2

eu gostaria de ver esse recurso em alguma linguagem, não só para que a função foo poderia retornar um casal ou um int ou uma corda, mas também para que foo poderia retornar uma estrutura ou objetos de diferentes classes. Disambiguating chamadas seria bastante trivial - se a chamada é ambígua, exigem um elenco para selecionar o tipo de retorno desejado. Exemplo:

string s = foo();    //foo returns a string
double x = foo();    //foo returns a double
int i = foo();       //foo returns an integer
float f = (float)(int)foo();    //call the int foo and convert to float

Além disso

Animal a = fooFactory();    //fooFactory returns an Animal
Plant p = fooFactory();     //foofactory returns a Plant

essas situações não surgem muito frequentemente, mas quando eles fazem a solução é muitas vezes bastante feio ...

Answer 3

double x = (double)foo();

A descrição acima é ambígua se existem versões de foo () que pode retornar double, int, float, etc.

Answer 4

Em C ++ você pode fazer isso com aulas em grande medida. Por exemplo, digamos que eu tenho um tipo de dados que é rotineiramente convertido em ASCII na entrada e saída;

typedef char* pchar;

class   MyType
{
public:

 operator pchar() { return(ConvertToASCII()); }
 MyType& operator=(char* input) { ConvertFromASCII(input); return(*this); }

 pchar ConvertToASCII();
 void ConvertFromASCII(pchar ASCII);
}

Este tipo de coisa é frequentemente usado em estruturas C ++. Por exemplo, ter um olhar para o implmentation da classe MFC CString. IMHO, é uma ferramenta muito útil, embora perigoso em determinadas circunstâncias.

Answer 5

Por causa de auto-conversão de tipos, não é óbvio para saber qual função a ser chamada quando tipos de retorno são próximos.