检查模板类的某些特化是否是特定类的基类的特征

Question

现代 STL 中有std::is_base_of。它可以让我们确定第二个参数是否派生自第一个参数，或者它们是否是相同的类，否则可以确定它们之间是否没有这种关系。

是否可以确定一个类是否派生自某个具体模板类而不区分其特化涉及哪些具体实际参数？

说，我们有；

template< typename ...types >
struct B {};

和

template< typename ...types >
struct D : B< types... > {};

是否可以定义类型特征：

template< typename T > is_derived_from_B;

这样当T 是D 的任何特化时它派生自std::true_type 并且如果T 不是从B 的任何特化派生自std::false_type？

Answer 1

如果您可以假设派生类型使用来自 B<Args...> 的公共继承（因此向上转换是可能的），那么您可以使用以下 SFINAE：

namespace detail
{
    template <typename Derived>
    struct is_derived_from_B
    {
        using U = typename std::remove_cv<
                                  typename std::remove_reference<Derived>::type
                                >::type;

        template <typename... Args>
        static auto test(B<Args...>*)
            -> typename std::integral_constant<bool
                                           , !std::is_same<U, B<Args...>>::value>;

        static std::false_type test(void*);

        using type = decltype(test(std::declval<U*>()));
    };
}

template <typename Derived>
using is_derived_from_B = typename detail::is_derived_from_B<Derived>::type;

测试：

static_assert(is_derived_from_B<const D<int, char, float>>::value, "!");
static_assert(!is_derived_from_B<int>::value, "!");
static_assert(!is_derived_from_B<B<int,int>>::value, "!");
static_assert(!is_derived_from_B<std::vector<int>>::value, "!");

DEMO 1

可以泛化为接受任何基类模板：

namespace detail
{
    template <template <typename...> class Base, typename Derived>
    struct is_derived_from_template
    {
        using U = typename std::remove_cv<
                                  typename std::remove_reference<Derived>::type
                                >::type;

        template <typename... Args>
        static auto test(Base<Args...>*)
            -> typename std::integral_constant<bool
                                          , !std::is_same<U, Base<Args...>>::value>;

        static std::false_type test(void*);

        using type = decltype(test(std::declval<U*>()));
    };
}

template <template <typename...> class Base, typename Derived>
using is_derived_from_template
                = typename detail::is_derived_from_template<Base, Derived>::type;

测试：

static_assert(is_derived_from_template<B, const D<int, int>>::value, "!");
static_assert(!is_derived_from_template<B, int>::value, "!");
static_assert(!is_derived_from_template<B, B<int, int>>::value, "!");
static_assert(!is_derived_from_template<B, std::vector<int>>::value, "!");

DEMO 2

Answer 2

我想提出另一种解决方案，它也适用于私有继承。缺点是它需要您修改基类模板，并且它是特定于基类的。

假设你的基类是template< typename... Args > class Base，你需要给它添加一个友元函数：

template< /*whatever*/ > class Base {
  //...

  template< typename T >
  friend std::enable_if_t<
    std::is_base_of<Base, T>::value
  > is_derived_from_Base_impl(T const&); //unevaluated-only
};

然后，你可以写出你的特质：

template< typename T, typename Enable=void >
struct is_derived_from_Base : std::false_type { };

template< typename T >
struct is_derived_from_Base<T,
  decltype(is_derived_from_Base_impl(std::declval<T const&>()))
> : std::true_type { };

此特性在更新 1 之前的 Visual Studio 2015 中不起作用，您必须编写如下内容：

namespace is_derived_from_Base_adl_barrier {
  struct no{}; //anything but void
  no is_derived_from_Base_impl(...);
  template< typename T >
  struct is_derived_from_Base : std::is_void<decltype(
    is_derived_from_Base_impl(std::declval<T const&>());
  )> { };
}
using is_derived_from_Base_adl_barrier::is_derived_from_Base;

这件事之所以有效，是因为尽管有私有继承，但依赖于参数名称的查找仍会找到友元函数，然后友元函数（或多个函数，如果找到多个）将检查is_base_of 的实际特化。