C ++ boost enable_if Frage
Frage
Muss ich jede mögliche Weise, die folgenden Anweisungen zu vereinfachen? (wahrscheinlich mit boost::enable_if
) .
Ich habe eine einfache Klassenstruktur -. Base
Basisklasse, Derived1
, Derived2
vererben Base
Ich habe den folgenden Code:
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;
};
Ich mag die gleiche Aussage mit einer Template-Spezialisierung von translator_between
schreiben zu können.
Ein Beispiel (Pseudo-Code) von dem, was ich schreiben können, möchte:
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;
};
Jede Art und Weise, dies mit boost::enable_if
und boost::is_base_of
zu erreichen?
Lösung
Als erstes müssen Sie Ihre Wahl unter dem Pick müssen:
-
is_base_of
-
is_convertible
kann sowohl in <boost/type_traits.hpp>
gefunden werden, wobei letztere mehr permissive.
Wenn Sie mit einfach der Instanziierung dieser Art für eine Kombination zu verhindern, dann eine statische assert verwenden:
// 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;
};
Da es keine Überlastung Auflösung stattfindet hier ist, die Sie nicht brauchen enable_if
.
Andere Tipps
I don''t denken boost::enable_if
hilft, weil SFINAE eher zu sein scheint zwischen Funktion Überlastungen zu wählen.
Sie können natürlich Vorlagen verwenden mit bool
Parameter, um die Wahl zu verfeinern:
#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
}
Sie können anable_if verwenden und dieses Makro hier, um es besser lesbar:
#define CLASS_REQUIRES(...) typename boost::enable_if<boost::mpl::and_<__VA_ARGS__, boost::mpl::bool_<true> > >::type
Dann können Sie Ihre Klasse wie folgt definiert werden:
template <typename Class, typename Y, class Enable =
CLASS_REQUIRES(boost::is_base_of<Class, Y>)>
struct translator_between {
typedef some_translator<Class, Y> type;
};