使用 SFINAE 分辨率区分普通模板参数和模板模板参数的技术

Question

这个问题的灵感来自最近出现的question about extended std::is_base_of type trait。

有什么技术可以让我们在现代 C++ 或其扩展中区分普通模板参数和模板模板参数（例如，-std=gnu++1zclang++/g++)?

namespace details
{

template< /* ??? */ base >
struct is_derived_from;

template< typaneme base >
struct is_derived_from< base >
{
    static std::true_type test(base *);
    static std::false_type test(void *);
};

template< template< typename ...formal > base >
struct is_derived_from< /* ??? */ >
{
    template< typename ...actual > // actual parameters must be here!
    static std::true_type test(base< actual... > *);
    static std::false_type test(void *);
};

} // namespace details

template< typename derived, /* ??? */ base >
using is_derived_from = decltype(details::is_derived_from< /* ? base< ? > */ >::test(std::declval< typename std::remove_cv< derived >::type * >()));

在积极的情况下，它允许我们使一些有用的类型特征更加强大（例如，STL 的std::is_base_of）。

我认为它需要一种语言特性作为“通用类型名”，不是吗？

Answer 1

类模板只能有一组模板参数，但您可以使用重载constexpr 函数模板来代替分派到适当的类模板。采用linked question 中的is_derived_from 特征，并带有一个额外的SFINAE 参数，这样当B 是一个不可访问或模棱两可的基时，您就不会遇到硬错误：

#include <type_traits>
namespace detail
{
    template <template <class...> class B, typename Derived>
    struct is_derived_from
    {
        using U = typename std::remove_cv<Derived>::type;

        template <typename... Args, 
                  typename = std::enable_if_t<
                             std::is_convertible<U*, Base<Args...>*>::value>>
        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*>()));
    };

    using std::is_base_of; // may want to use is_convertible instead to match
                           // the semantics of is_derived_from
}

template <template <class...> class B, typename Derived>
constexpr bool my_is_base_of() { return detail::is_derived_from<B, Derived>::type::value; }

template <class B, typename Derived>
constexpr bool my_is_base_of() { return detail::is_base_of<B,Derived>::value; }

struct B {};
struct D : B {};

template<class ...>
struct B2 {}; 
struct D2 : B2<int, double> { };

int main() {
  static_assert(my_is_base_of<B2, D2>(), "Oops");
  static_assert(my_is_base_of<B, D>(), "Oops");
  static_assert(my_is_base_of<B2<int, double>, D2>(), "Oops");
  static_assert(!my_is_base_of<B, D2>(), "Oops");
}

Demo.

Answer 2

你问：

有什么技术可以让我们区分普通模板参数和现代 C++ 或其扩展中的模板模板参数（例如，-std=gnu++1zclang++/g++）？

在我看来你需要类似的东西：

template <typename T>
struct is_template_template : public std::false_type
{
};

template <typename T1, template <typename T> class T2>
struct is_template_template<T2<T1>> : std::true_type
{
};

示例程序

#include <iostream>

template <typename T>
struct is_template_template : public std::false_type
{
};

template <typename T1, template <typename T> class T2>
struct is_template_template<T2<T1>> : std::true_type
{
};

template <typename T> struct A {};
struct B {};

int main()
{
   std::cout << std::boolalpha;
   std::cout << is_template_template<A<int>>::value << std::endl;
   std::cout << is_template_template<B>::value << std::endl;
   return 0;
}

输出：

真的 错误的