C++ partial template specialization in combination with std::is_base_of and std::enable_if

Question

Let's say I have a two classes: Serializable and Printable.

So a simple template function which accepts all derived classes of Printable could look like:

template <class T, class B = Printable, class = typename std::enable_if<std::is_base_of<B,     T>::value>::type> void print(T value) {     cout << value << endl; } 

However, if I want it to accept also all derived classes of Serializable while I still have control over the function body, this would obviously not work:

template <class T, class B = Printable, class = typename std::enable_if<std::is_base_of<B,     T>::value>::type> void print(T value) {     cout << value << endl; }  template <class T, class B = Serializable, class = typename std::enable_if<std::is_base_of<B,     T>::value>::type> void print(T value) {     cout << value << endl; }  // Error: Redefinition of ... 

So I figured the remaining solutions for this problem are template specializations.

But I just can't figure out, how I can specialize a template in combination with std::is_base_of and std::enable_if.

I hope someone is willing to help me!

Answer 1

Try a logical operator:

std::enable_if<std::is_base_of<Serializable, T>::value ||                std::is_base_of<Printable, T>::value>::type 

You can easily write a variadic template like:

is_base_of_any<T, Printable, Serialiable, Googlable, Foobarable>::value 

For example:

template <typename T, typename ...> struct is_base_of_any : std::true_type {};  template <typename T, typename Head, typename ...Rest> struct is_base_of_any<T, Head, Rest...> : std::integral_constant<bool, std::is_base_of<T, Head>::value ||                                is_base_of_any<T, Rest...>::value> { }; 

---

If you want different implementations:

template <bool...> struct tag_type {};  template <typename T> void foo(T, tag_type<true, false>) { }   // for Printable  template <typename T> void foo(T, tag_type<false, true>) { }   // for Serializable  template <typename T> void foo(T x) {     foo(x, tag_type<std::is_base_of<Printable, T>::value,                     std::is_base_of<Serializable, T>::value>()); } 

The last overload (the "user-facing" one) should probably be endowed with the above enable_if to not create overly many overload candidates.

You can probably also make a variadic template <typename ...Bases> with a tag like:

tag_type<std::is_base_of<Bases, T>::value...>