c++ - usados - editor de codigo de visual basic net

Llamar a la función de plantilla sin<>; escriba inferencia

Question

Si tengo una plantilla de función con typename T , donde el compilador puede establecer el tipo por sí mismo, no tengo que escribir el tipo explícitamente cuando llamo a la función como:

template < typename T > 
T min( T v1, T v2 ) {
   return ( v1 < v2 ) ? v1: v2;
}
int i1 = 1, i2 = 2; int i3 = min( i1, i2 ); //no explicit <type> 

Pero si tengo una plantilla de función con dos tipos de letra diferentes, como:

template < typename TOut, typename TIn >
TOut round( TIn v ) {
   return (TOut)( v + 0.5 );
}
double d = 1.54;
int i = round<int>(d); //explicit <int>

¿Es verdad que siempre tengo que especificar al menos 1 nombre de tipo? Supongo que la razón es porque C ++ no puede distinguir funciones entre diferentes tipos de retorno.

Pero si utilizo una función void y una referencia de handover, nuevamente no debo especificar explícitamente el nombre de tipo de retorno:

template < typename TOut, typename TIn > 
void round( TOut & vret, TIn vin ) {
   vret = (TOut)(vin + 0.5);
}
   double d = 1.54;
   int i; round(i, d); //no explicit <int>

¿Debería la conclusión ser para evitar las funciones con retorno y más las funciones void que regresan a través de una referencia al escribir plantillas? ¿O existe la posibilidad de evitar escribir explícitamente el tipo de devolución? Algo así como "tipo de inferencia" para plantillas. ¿Es posible la "inferencia de tipo" en C ++ 0x?

Answer 1

la conclusión es evitar las funciones con retorno y más preferir las funciones vacías que regresan a través de una referencia al escribir plantillas

¿No porque? ¿Qué ganas? Solo escriba inferencia (por lo tanto, menos código para escribir). Pero pierde la sintaxis mucho más lógica de asignar un valor (y en consecuencia más código para escribir). Así que una cosa ganó, otra perdió. No veo el beneficio en general.

Incluso puede ser útil tener que especificar explícitamente el tipo de plantilla: considere el caso de lexical_cast . No especificar el tipo de plantilla de devolución sería confuso.

Answer 2

La resolución de sobrecarga solo se realiza en función de los argumentos de la función; el valor de retorno no se usa en absoluto. Si el tipo de devolución no puede determinarse según los argumentos, deberá especificarlo explícitamente.

No iría por el camino de "devolver" un valor a través de un parámetro de referencia; eso hace que el código de llamada no sea claro. Por ejemplo, preferiría esto:

double x = round<double>(y);

Más allá de esto:

double x;
round(x, y);

porque en este último caso, es fácil confundir entrada y salida, y no está del todo claro que x se esté modificando.

En el caso particular de round , probablemente solo necesites uno o dos tipos para TOut todos modos, así que puedes dejar el argumento de la plantilla:

template<typename TIn>
int roundToInt(TIn v) {
    return (int)(v + 0.5);
}

Encuentro roundToInt(x) un poco más claro que round<int>(x) porque está claro para qué se usa el tipo int .

Answer 3

Permítanme agregar a lo que han dicho los demás al decir que deberían preferir el casting de C ++ sobre el fundido de estilo C.

vret = (TOut)(vin + 0.5);

versus

vret = static_cast<TOut>(vin + 0.5);

el lanzamiento estático siempre fallará si intentas convertir tipos no relacionados. Esto puede ayudar con la depuración.