Parando a conversão implícita da função

Question

Me deparei com uma situação estranha hoje, onde precisava de uma função para não converter implicitamente valores.

Depois de alguns olhando no google, encontrei isso http://www.devx.com/cplus/10minutesolution/37078/1954

Mas eu pensei que era um pouco estúpido usar uma sobrecarga de função para qualquer outro tipo que eu queira bloquear, então, em vez disso, fiz isso.

void function(int& ints_only_please){}


int main () {char a = 0; int b = 0; função (a); função (b); }

Eu mostrei o código para um amigo e ele sugeriu que eu adicionei const antes int, para que a variável não seja editável, no entanto, quando eu comecei a compilar bem, mas não deveria, olhe abaixo para ver o que quero dizer

void function(const int& ints_only_please){}


int main () {char a = 0; int b = 0; função (a); // O compilador deve parar por aqui, mas não com a função const int (b); }

Alguém sabe por que isso é?

Answer 1

Use modelos para obter o efeito desejado:

template <class T>
void foo(const T& t);

template <>
void foo<int>(const int& t)
{

}

int main(){
  foo(9); // will compile
  foo(9.0); // will not compile
  return 0;
}

Observe que apenas escrevemos uma versão especial do modelo para int para que uma chamada que tenha qualquer outro tipo como parâmetro de modelo resulte em um erro de compilação.

Answer 2

É legal vincular um temporário a um const referência, mas não um nãoconst referência.

UMA char pode ser implicitamente convertido em um int e o temporário que é o resultado dessa conversão pode estar ligado a um const int& O parâmetro da função que estende a vida útil do temporário até que a função saia.