如何检查函数中的模板参数是否与给定类型别名的特化相匹配

Question

我有以下代码：

template <template <class...> class Temp, class Specialization>
struct IsSpecialization : std::false_type {};


template <template <typename...> class Temp1,
          template <typename...> class Temp2, typename... Ts>
struct IsSpecialization<Temp1, Temp2<Ts...>>
    : std::is_same<Temp1<Ts...>, Temp2<Ts...>> {};

struct ExprKindMerge {};
struct ExprKindSequence {};

template <class Tag, class... Args>
struct Expr {
    std::tuple<Args...> tup;

    constexpr std::tuple<Args...> toStdTuple() const {
        return this->tup;
    }

    constexpr std::size_t size() const noexcept {
        return std::tuple_size<decltype(tup)>{};
    }
};

template <class...Args>
using MergeExpr = Expr<ExprKindMerge, Args...>;

template <class...Args>
using SequenceExpr = Expr<ExprKindSequence, Args...>;

而这个函数有时会接收一个SequenceExpr<Something>作为模板参数：

template <class FullExpr>
auto f(FullExpr expr) {
    ///**************THIS RETURNS FALSE I EXPECT TRUE
    ///Type of full expr is Expr<ExprKindSequence, ...> which is
    /// the expansion of SequenceExpr<...>
    if constexpr (IsSpecialization<SequenceExpr, FullExpr>::value) 
    //...
}

我希望能够检测FullExpr是否是SequenceExpr但由于某种未知原因它失败了。

Answer 1

失败的原因很简单。 对于SequenceExpr<ExtraArgs...> ， Temp2被推断为Expr ， Ts...被推断为ExprKindSequence, ExtraArgs... 然后Temp1<Ts...>是Expr<ExprKindSequence, ExprKindSequence, ExtraArgs...> ，显然与Temp2<Ts...> 。

我知道没有完全通用的方法来做到这一点。 毕竟，这样一个假设的模板可能需要为IsSpecialization<std::remove_reference_t, int>返回true ...

如果我们把它限制在使用他们的参数推断出上下文（这是你的榜样的情况下）的别名模板，那么一个可能的方法是问“我可以推导出Ts...在Temp<Ts...>来自Specialization ？“：

namespace detail {
    template<class> class type {};
    template<template<class...> class Temp, class...Ts>
    void try_deduce(type<Temp<Ts...>>);
}

template <template <class...> class, class, class = void>
struct IsSpecialization : std::false_type {};

template <template <typename...> class Temp, class Specialization>
struct IsSpecialization<Temp, Specialization, 
                        decltype(detail::try_deduce<Temp>(detail::type<Specialization>()))>
    : std::true_type {};

static_assert(IsSpecialization<SequenceExpr, SequenceExpr<int>>()());
static_assert(IsSpecialization<Expr, SequenceExpr<int>>()());
static_assert(!IsSpecialization<MergeExpr, SequenceExpr<int>>()());
static_assert(!IsSpecialization<SequenceExpr, MergeExpr<int>>()());

Answer 2

如果您只对检测SequenceExpr的特化感兴趣，我能想象的最好的是添加一个IsSpecialization定义如下

template <typename... Ts>
struct IsSpecialization<SequenceExpr, Expr<ExprKindSequence, Ts...>>
    : std::true_type
 { };

显然，这不是我认为不可能的一般解决方案。

如果你用（例如） Expr<ExprKindSequence, int, long>值调用f ，请Expr<ExprKindSequence, int, long>

f(Expr<ExprKindSequence, int, long>{});  // result true !!!

以上匹配的IsSpecialization的专业化，你得到了true ; 我不知道你想要的是什么。

以下是一个完整的工作示例

#include <tuple>
#include <iostream>
#include <type_traits>

template <template <typename...> typename Temp, typename Specialization>
struct IsSpecialization : std::false_type
 { };

template <template <typename...> class Temp1,
          template <typename...> class Temp2, typename... Ts>
struct IsSpecialization<Temp1, Temp2<Ts...>>
    : std::is_same<Temp1<Ts...>, Temp2<Ts...>>
 { };

struct ExprKindMerge {};
struct ExprKindSequence {};

template <typename Tag, typename... Args>
struct Expr
 {
    std::tuple<Args...> tup;

    constexpr std::tuple<Args...> toStdTuple () const
     { return this->tup; }

    constexpr std::size_t size () const noexcept
     { return std::tuple_size<decltype(tup)>{}; }
 };

template <typename ... Args>
using MergeExpr = Expr<ExprKindMerge, Args...>;

template <typename ... Args>
using SequenceExpr = Expr<ExprKindSequence, Args...>;

template <typename ... Ts>
struct IsSpecialization<SequenceExpr, Expr<ExprKindSequence, Ts...>>
    : std::true_type
 { };

template <class FE>
auto f (FE expr)
 { std::cout << IsSpecialization<SequenceExpr, FE>::value << std::endl; }

int main ()
 {
   f(SequenceExpr<int, long>{});             // print 1
   f(Expr<ExprKindSequence, int, long>{});   // print 1  (?)
   f(Expr<int, long>{});                     // print 0
   f(int{});                                 // print 0
 }