Comprueba si el paquete de parámetros C++ 0x contiene un tipo

Question

Me preguntaba si C++ 0x ofrece alguna función integrada para comprobar si un paquete de parámetros de una plantilla variadic contiene un tipo específico. Hoy, boost ::: mpl :: contains se puede usar para lograr esto si está utilizando boost :: mpl :: vector como sustituto de las plantillas variadic adecuadas. Sin embargo, tiene un tiempo de compilación serio. Supongo que C++ 0x tiene soporte de compilación para std :: is_same. Así que estaba pensando si una generalización como a continuación también es compatible en el compilador.

template <typename... Args, typename What> 
struct is_present 
{ 
    enum { value = (What in Args...)? 1 : 0 }; 
}; 

Answer 1

No, usted tiene que utilizar la especialización (parcial) con plantillas variadic hacer en tiempo de compilación cálculos de este tipo:

#include <type_traits> 

template < typename Tp, typename... List > 
struct contains : std::true_type {}; 

template < typename Tp, typename Head, typename... Rest > 
struct contains<Tp, Head, Rest...> 
: std::conditional< std::is_same<Tp, Head>::value, 
    std::true_type, 
    contains<Tp, Rest...> 
>::type {}; 

template < typename Tp > 
struct contains<Tp> : std::false_type {}; 

Sólo hay una otra operación intrínseca para las plantillas variadic y que es la forma especial del operador sizeof que calcula la longitud de la lista de parámetros, por ejemplo:

template < typename... Types > 
struct typelist_len 
{ 
    const static size_t value = sizeof...(Types); 
}; 

Dónde estás recibiendo "tiene graves sobrecarga en tiempo de compilación" con impulsar mpl desde? Espero que no solo hagas suposiciones aquí. Boost mpl usa técnicas como la creación de instancias de plantillas perezosas para intentar reducir los tiempos de compilación en lugar de explotar como lo hace la meta-programación ingenua.

Answer 2

Si desea evitar la recursión de tipo manual, std::common_type me parece ser la única utilidad en el STL que es una plantilla variadic, y por lo tanto la única que podría encapsular la recursión.

Solución 1

std::common_type encuentra el tipo menos derivado en un conjunto de tipos. Si identificamos números con tipos, específicamente números altos con tipos menos derivados, encuentra el mayor número en un conjunto. Luego, tenemos que asignar la igualdad al tipo de clave en un nivel de derivación.

using namespace std; 

struct base_one { enum { value = 1 }; }; 
struct derived_zero : base_one { enum { value = 0 }; }; 

template< typename A, typename B > 
struct type_equal { 
typedef derived_zero type; 
}; 

template< typename A > 
struct type_equal< A, A > { 
typedef base_one type; 
}; 

template< typename Key, typename ... Types > 
struct pack_any { 
enum { value = 
    common_type< typename type_equal< Key, Types >::type ... >::type::value }; 
}; 

Solución 2

Podemos cortar common_type un poco más. El estándar dice

Un programa puede especializarse este rasgo si al menos un parámetro de plantilla en la especialización es un tipo definido por el usuario.

y describe exactamente lo que contiene: un caso de especialización recursiva parcial, un caso que aplica un operador binario y un caso de terminal. Esencialmente, es una función genérica fold, y puede agregar cualquier operación binaria que desee. Aquí utilicé la suma porque es más informativo que OR. Tenga en cuenta que is_same devuelve integral_constant.

template< typename Addend > 
struct type_sum { // need to define a dummy type to turn common_type into a sum 
    typedef Addend type; 
}; 

namespace std { // allowed to specialize this particular template 
template< typename LHS, typename RHS > 
struct common_type< type_sum<LHS>, type_sum<RHS> > { 
    typedef type_sum< integral_constant< int, 
    LHS::type::value + RHS::type::value > > type; // <= addition here 
}; 
} 

template< typename Key, typename ... Types > 
struct pack_count : integral_constant< int, 
common_type< type_sum< is_same< Key, Types > > ... >::type::type::value > {};