std::is_base_of for template classes

Question

Is there a way to test std::is_base_of<A, B> when A is a template class?

template <typename X, typename Y> class A {};

template <typename X> class B : public A<X, char> {};

I want to statically test something like, std::is_base_of<A, B<int>> meaning, B is derived from any specialization of A. (To make it more general, let's say we don't know the way B specializes A, i.e. B<X> derives from A<X, char>)

One way to solve would be to derived A from a (non-template) class say C, and then check std::is_base_of<C, B<int>>. But is there another way to do this?

'A' is not a type. You cant do that, but you can do 'std::is_base_of, B>' — Arunmu, Jan 08 '16 at 08:26
Kind of similar question I answered some time back. http://stackoverflow.com/questions/34670375/how-to-enforce-template-parameter-class-to-derive-from-super-with-an-anonymous-t/34670684#34670684 — Arunmu, Jan 08 '16 at 08:27
@TartanLlama thanks. It would be very specific to the way B specializes A though. I am looking for a more general solution, if possible. — Saswat Padhi, Jan 08 '16 at 08:31

score 29 · Accepted Answer · edited Aug 23 '18 at 09:14

29

You may do the following:

template <template <typename...> class C, typename...Ts>
std::true_type is_base_of_template_impl(const C<Ts...>*);

template <template <typename...> class C>
std::false_type is_base_of_template_impl(...);

template <typename T, template <typename...> class C>
using is_base_of_template = decltype(is_base_of_template_impl<C>(std::declval<T*>()));

Live Demo

but will fail with multiple inheritance or private inheritance from A.

With Visual Studio 2017 this will fail when the base class template has more than one template parameter, and it is unable to deduce Ts...

Demo

VS Bug Report

Refactoring solves the problem for VS.

template < template <typename...> class base,typename derived>
struct is_base_of_template_impl
{
    template<typename... Ts>
    static constexpr std::true_type  test(const base<Ts...> *);
    static constexpr std::false_type test(...);
    using type = decltype(test(std::declval<derived*>()));
};

template < template <typename...> class base,typename derived>
using is_base_of_template = typename is_base_of_template_impl<base,derived>::type;

Live Demo

edited Aug 23 '18 at 09:14

rmawatson

1,909
12
20

answered Jan 08 '16 at 08:44

Jarod42

203,559
14
181
302

1

Huh, I had no idea that `Ts...` could be deduced in that context. Nice! – TartanLlama Jan 08 '16 at 08:47
2

I arrived at the same solution, but this solution also __fails__ (rather than returns `false`) with single non-public inheritance from `A` :( – mpark Jan 08 '16 at 08:59
2

@Jarod42: Thanks! That's pretty clever. – Saswat Padhi Jan 08 '16 at 09:22
2

It seems you don't need the `typename T` in `is_base_of_template_impl`? – davidhigh Jan 08 '16 at 09:45
@davidhigh: Indeed, simplified. – Jarod42 Jan 08 '16 at 10:36
Why does this fail with multiple inheritance? – Justin Mar 26 '17 at 17:50
@Justin: In case you inherit from both `C` and `C`. – Jarod42 Mar 26 '17 at 18:03
Unfortunately this breaks in visual studio with more than 1 template parameter unless the second parameter is varadic... - http://rextester.com/CSMZ66843 – rmawatson Aug 22 '18 at 14:48
Well, the VS bug is fixed. – Deduplicator Jul 08 '19 at 10:53
1

It doesn't work when the template arguments contain values, anyone any ideas? – Sprite Dec 20 '20 at 18:24
2

@Sprite: we unfortunately don't have syntax to handle generically between type and non-type template parameters. You have to create similar traits to handle types as `std::array`. – Jarod42 Dec 20 '20 at 22:45
@Jarod42 I am an engineer at Google interested in using the code you wrote here. If you are comfortable with permitting this, could you please release your snippet under a recognized open source license (https://opensource.org/licenses) by adding a comment clarifying which specific license terms apply to this snippet of code? Thanks for your help. – Jack Humphries Jan 25 '22 at 20:37
@JackHumphries: Just added in my profile the fact that original code I post on SO are under [MIT license](https://opensource.org/licenses/MIT). – Jarod42 Jan 26 '22 at 08:55
@Jarod42 Thank you! – Jack Humphries Jan 26 '22 at 20:52

score 2 · Answer 2 · answered Aug 24 '20 at 14:15

Bit late to the party here but I wanted to give a variant of the above

template < template <typename...> class Base,typename Derived>
struct is_base_of_template
{
    // A function which can only be called by something convertible to a Base<Ts...>*
    // We return a std::variant here as a way of "returning" a parameter pack
    template<typename... Ts> static constexpr std::variant<Ts...> is_callable( Base<Ts...>* );

    // Detector, will return type of calling is_callable, or it won't compile if that can't be done
    template <typename T> using is_callable_t = decltype( is_callable( std::declval<T*>() ) );

    // Is it possible to call is_callable which the Derived type
    static inline constexpr bool value = std::experimental::is_detected_v<is_callable_t,Derived>;

    // If it is possible to call is_callable with the Derived type what would it return, if not type is a void
    using type = std::experimental::detected_or_t<void,is_callable_t,Derived>;
};

template < template <typename...> class Base,typename Derived> 
using is_base_of_template_t = typename is_base_of_template<Base,Derived>::type;

template < template <typename...> class Base,typename Derived>
inline constexpr bool is_base_of_template_v = is_base_of_template<Base,Derived>::value;

This uses the proposed is_detected machanism which I think makes the intent of the test a bit clearer. However I can now get the type(s) with which the base class is instantiated at the same time which I find useful. So I can write

template <typename T, typename U> struct Foo { };

struct Bar : Foo<int,std::string> { };

static_assert( is_base_of_template_v<Foo,Bar> );

// The variant type contains the types with which the Foo base is instantiated 
static_assert( std::is_same_v<std::variant<int,std::string>,is_base_of_template_t<Foo,Bar>> );

score 1 · Answer 3 · answered Mar 07 '18 at 23:47

The following solution works with protected inheritance.

template <template <typename...> class BaseTemplate, typename Derived, typename TCheck = void>
struct test_base_template;

template <template <typename...> class BaseTemplate, typename Derived>
using is_base_template_of = typename test_base_template<BaseTemplate, Derived>::is_base;

//Derive - is a class. Let inherit from Derive, so it can cast to its protected parents
template <template <typename...> class BaseTemplate, typename Derived>
struct test_base_template<BaseTemplate, Derived, std::enable_if_t<std::is_class_v<Derived>>> : Derived
{
    template<typename...T>
    static constexpr std::true_type test(BaseTemplate<T...> *);
    static constexpr std::false_type test(...);
    using is_base = decltype(test((test_base_template *) nullptr));
};

//Derive - is not a class, so it is always false_type
template <template <typename...> class BaseTemplate, typename Derived>
struct test_base_template<BaseTemplate, Derived, std::enable_if_t<!std::is_class_v<Derived>>>
{
    using is_base = std::false_type;
};

Surprisingly, on VS2017, it works with multiple inheritance from the same template, like C< int > and C< float > both. (have no idea how!)

Check the Link to test code

Your solution is quite good but it has a minor bug try to test static_assert(is_base_template_of>::value); — Anton Dyachenko, May 07 '18 at 09:47

score 1 · Answer 4 · answered May 07 '18 at 10:00

Based on Evgeny Mamontov answer I believe the proper solution is

template <template <typename...> class BaseTemplate, typename Derived>
struct test_base_template<BaseTemplate, Derived, std::enable_if_t<std::is_class_v<Derived>>> : Derived
{
    template<typename...T>
    static constexpr std::true_type test(BaseTemplate<T...> *);
    static constexpr std::false_type test(...);
    using is_base = decltype(test((Derived *) nullptr));
};

std::is_base_of for template classes

4 Answers4

Linked

Related