funzione di arresto conversione implicita

Question

mi sono imbattuto in una strana situazione di oggi in cui avevo bisogno di una funzione per non convertire implicitamente valori.

Dopo qualche ricerca su google ho trovato questo http://www.devx.com/cplus/10MinuteSolution/37078 / 1954

Ma ho pensato che fosse un po 'stupido per usare un sovraccarico di funzioni per ogni altro tipo che voglio bloccare così invece ho fatto questo.

void function(int& ints_only_please){}


int main()
{
    char a=0;
    int b=0;
    function(a);
    function(b);
}

ho mostrato il codice per un amico e lui ha suggerito ho aggiunto const prima int in modo che la variabile non è modificabile, ma quando ho iniziato a compilare bene, ma non dovrebbe, un'occhiata qui sotto per vedere quello che voglio dire

void function(const int& ints_only_please){}


int main()
{
    char a=0;
    int b=0;
    function(a); //Compiler should stop here but it doesn't with const int
    function(b);
}

Qualcuno sa perché questo è?

Answer 1

utilizzare i modelli per ottenere l'effetto desiderato:

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

Si noti che abbiamo solo scrivere una versione speciale del modello per int in modo che una chiamata che ha qualsiasi altro tipo come parametro di template si tradurrà in un errore di compilazione.

Answer 2

E 'legale per vincolare un temporaneo per un riferimento const, ma non un riferimento non const.

Un char può essere convertito in modo implicito un int e la temporanea che è il risultato di questa conversione può essere legato ad un parametro di funzione const int& estendere la vita del temporaneo fino a quando la funzione termina.