variante mínima y máxima de plantillas en C++ 11?

Question

Estoy en lo cierto en la lectura de la norma que a partir de min y max (y minmax para el caso) no son nuevos initializer_list variantes, pero no hay plantilla variadic variantes?

Por lo tanto, esto está bien:

int a = min({ 1,2,a,b,5 }); 

pero esto no es:

int b = min(1,2,a,b,5); // err! 

supongo, muchas personas esperarían que las plantillas variadic podría haber implementado fácilmente este, por lo que podrían ser decepcionado .

Yo diría que usar V.T. para min y max sería una exageración plantillas

• variadic son capaces de manejar múltiples tipos
• listas de inicializador verificación de que todos los tipos son los mismos por diseño

por lo tanto, I. L. son mucho más adecuados para la tarea.

¿Mi interpretación es correcta?

Answer 1

Su interpretación es correcta. N2772 contiene un fundamento más profundo.

Answer 2

Sí, creo que es justo decir que tener todos los valores de tipos compatibles hace que las listas sean un buen candidato para esta función. Eso no quiere decir que no puedas escribir tu propia versión de plantilla variadica.

Answer 3

Aquí está mi solución usando plantillas variadic con y sin Boost Concepts Rasgos comunes del tipo para min probado en GCC 4.6. Aunque no estoy seguro de si Common_type es necesario o no.

#define LessThanComparable class 
#include <boost/type_traits/common_type.hpp> 


/*! Multi-Type Minimum of \p a. */ 
template <LessThanComparable T> const T & multi_type_min (const T & a) { return a; } // template termination 
/*! Multi-Type Minimum of \p a, \p b and \p args. */ 
template <class T, class ... R > 
//requires SameType <T , Args >... 
T multi_type_min(const T & a, const T & b, const R &... args) 
{ 
    return multi_type_min(a < b ? a : b, args...); 
} 

/*! Minimum of \p a. */ 
template <LessThanComparable T> const T & min(const T & a) { return a; } // template termination 
/*! Minimum of \p a, \p b and \p args. */ 
template <class T, class U, class ... R, class C = typename boost::common_type<T, U, R...>::type > 
C min(const T & a, const U & b, const R &... c) 
{ 
    return min(static_cast<C>(a < b ? a : b), static_cast<C>(c)...); 
}