C ++ pregunta impulso enable_if
Pregunta
¿Tengo alguna forma de simplificar las siguientes afirmaciones? (probablemente, usando boost::enable_if
) .
Tengo una estructura de clases sencilla -. Base
clase base, Derived1
, hereda Derived2
de Base
Tengo el siguiente código:
template <typename Y> struct translator_between<Base, Y> {
typedef some_translator<Base, Y> type;
};
template <typename Y> struct translator_between<Derived1, Y> {
typedef some_translator<Derived1, Y> type;
};
template <typename Y> struct translator_between<Derived2, Y> {
typedef some_translator<Derived2, Y> type;
};
Quiero escribir la misma declaración utilizando una especialización de plantilla de translator_between
.
Un ejemplo (pseudocódigo) de lo que yo quiero ser capaz de escribir:
template <typename Class, typename Y>
ONLY_INSTANTIATE_THIS_TEMPLATE_IF (Class is 'Base' or any derived from 'Base')
struct translator_between<Class, Y> {
typedef some_translator<Class, Y> type;
};
Cualquier forma de lograr esto usando boost::enable_if
y boost::is_base_of
?
Solución
En primer lugar, usted tiene que escoger su opción entre:
-
is_base_of
-
is_convertible
tanto se puede encontrar en <boost/type_traits.hpp>
, siendo este último más permisiva.
Si con simplemente evitar la creación de instancias de este tipo para alguna combinación, a continuación, utilizar una aserción estática:
// C++03
#include <boost/mpl/assert.hpp>
template <typename From, typename To>
struct translator_between
{
BOOST_MPL_ASSERT((boost::is_base_of<To,From>));
typedef translator_selector<From,To> type;
};
// C++0x
template <typename From, typename To>
struct translator_between
{
static_assert(boost::is_base_of<To,From>::value,
"From does not derive from To");
typedef translator_selector<From,To> type;
};
Dado que no hay sobrecarga de resolución que tiene lugar aquí, no es necesario enable_if
.
Otros consejos
I Don''t que boost::enable_if
ayuda, porque SFINAE parece ser más bien sobre la selección entre las sobrecargas de función.
Puede utilizar plantillas de curso con parámetros bool
para refinar la elección:
#include <boost/type_traits.hpp>
class Base {};
class Derived : public Base {};
template <class A, class B>
struct some_translator {};
template <typename A, typename B, bool value>
struct translator_selector; //perhaps define type as needed
template <typename A, typename B>
struct translator_selector<A, B, true>
{
typedef some_translator<A, B> type;
};
template <typename A, typename B>
struct translator_between
{
typedef typename translator_selector<A, B, boost::is_base_of<Base, A>::value>::type type;
};
int main()
{
translator_between<Base, int>::type a;
translator_between<Derived, int>::type b;
translator_between<float, int>::type c; //fails
}
Puede utilizar esta macro y anable_if aquí para hacerlo más legible:
#define CLASS_REQUIRES(...) typename boost::enable_if<boost::mpl::and_<__VA_ARGS__, boost::mpl::bool_<true> > >::type
A continuación, puede definir la clase de esta manera:
template <typename Class, typename Y, class Enable =
CLASS_REQUIRES(boost::is_base_of<Class, Y>)>
struct translator_between {
typedef some_translator<Class, Y> type;
};