c++ - sacar - numeros perfectos lista

Reenvío perfecto en C++ 03

Question

Si tienes esta función

template<typename T> f(T&);

Y luego intente llamarlo, digamos un valor como

f(1);

¿Por qué no se deduce que T sea constante, lo que hace que el argumento sea una constante y, por lo tanto, sea vinculable a un valor?

Answer 1

Esto se menciona como una solución potencial en el documento que vinculé en la reciente pregunta de envío de C ++ 0x .

Funcionaría bastante bien, pero rompe el código existente. Considere (directamente del documento):

template<class A1> void f(A1 & a1)
{
std::cout << 1 << std::endl;
}
void f(long const &)
{
std::cout << 2 << std::endl;
}
int main()
{
f(5); // prints 2 under the current rules, 1 after the change
int const n(5);
f(n); // 1 in both cases
}

O

// helper function in a header
template<class T> void something(T & t) // #1
{
t.something();
}
// source
#include <vector>
void something(bool) // #2
{
}
int main()
{
std::vector<bool> v(5);
// resolves to #2 under the current rules, #1 after the change
something(v[0]);
}

Esto también falla al reenviar la categoría de valor (lvalue o rvalue), que no es un gran problema en C ++ 03. Pero como esta solución solo se podía hacer durante C ++ 0x, efectivamente nos excluíamos de las referencias de valor cuando enviamos (algo malo). Debemos esforzarnos por una mejor solución.

Answer 2

Lo es, pero solo si declara f para tomar T const & .

template <typename T> void f(T &);
template <typename T> void g(T const &);
void x() { f(1); } // error: invalid initialization of non-const reference
void y() { g(1); } // no error

Y si declara tanto f(T &) como f(T const &) , elegirá el cualificado por const:

template <typename T> void f(T &);
template <typename T> void f(T const &);
void x() { f(1); } // no error, calls f(T const &)

Tal vez esté diciendo "en el primer ejemplo, ¿por qué genera un temporal de tipo int para la llamada a f cuando podría haber generado un temporal de tipo const int y compilado el código?" La mejor respuesta que tengo para es que eso sería inconsistente con el comportamiento de resolución de sobrecarga cuando el argumento no es una constante entera.