基于部分模板模板的专业化与显式部分模板专业化

Question

给定一个模板,例如foo:

template<typename... ARGS>
struct foo {};

以及模板的两个部分特化bar:

template<template<typename...> class T , typename... ARGS>
struct bar<T<ARGS...>>
{};

template<typename... ARGS>
struct bar<foo<ARGS...>>
{};

是不是第二个部分特化比第一个更专业,必须是实例而不是模板模板参数专门化？

一些背景:

我正在基于本文编写用于模板元编程的多变量lambda表达式.

正如文章所示,给定类似Haskell的let表达式,可以很容易地开发tmp lambda 表达式.在我的例子中,我已经扩展了论文的内容,开发了基于variadic-templates的多变量let表达式(通过curryfying多个嵌套的一元let表达式),然后实现多变量lambda表达式.

我的lambda表达式模板,tml::multi_lambda定义如下:

template<typename BODY , typename... VARIABLES>
struct multi_lambda
{
    template<typename... ARGS>
    using result = tml::eval<tml::multi_let<VARIABLES...,
                                            ARGS...,
                                            BODY
                                           >>;
};

其中tml::eval是一个用于评估表达式的元函数,如Boost :: mpl mpl::apply(有关更多上下文,请参阅我之前的问题).

评估函数tml::eval专用于通用函数表达式,特别是对于此lambda表达式.这是上述示例的两个特化.

当我尝试评估lambda表达式时,例如:

using lambda = tml::multi_lambda<_1,_2, f<_1,_2>>; //f is a function, 
                                                   //_1 _2 are placeholders
using result = tml::eval<lambda,int,int>; //Evaluate lambda with int int as parameters

tml::eval 实例化通用模板模板特化(专为通用可评估表达式设计)而不是lambdas的部分特化.

编辑:tml::eval和SSCCE的实施

tml::eval是一个元函数,用于评估任何类型的表达式,返回结果.默认实现专门针对三种情况:

1. 表达式不是函数,只是一个值:评估此类表达式的结果是表达式本身:

   template<typename E>
   struct evaluate_impl<E>
   {
       using result = E;
   }; 
   

2. 表达式是一个函数:评估的结果是函数的result成员类型的值.函数的参数也被评估(为了处理嵌套表达式):

   template<template<typename...> class F , typename... ARGS>
   struct evaluate_impl<F<ARGS...>> : public F<tml::eval<ARGS>...>
   {};
   

3. 表达式是一个函数,并传递更多的argumments以tml::eval使用该自定义argumments计算表达式:忽略表达式的参数并传递和计算自定义:

   template<template<typename...> class F , typename... PLACEHOLDERS , typename... ARGS>
   struct evaluate_impl<F<PLACEHOLDERS...>,ARGS...> : public F<tml::eval<ARGS>...>
   {};
   

所以tml::eval只是一个模板别名来骑过typename ::result:

template<typename... ARGS>
using eval = typename eval_impl<ARGS...>::result;

最后,用户可以专门eval_impl覆盖该默认行为,或使角落案例工作.例如,我的单变量lambda表达式模板,定义如下:

template<typename VARIABLE , typename VALUE , typename BODY>
struct lambda
{
    template<typename ARG>
    using result = tml::eval<tml::let<VARIABLE , ARG , BODY>>;
};

专门eval_impl评估lambda表达式的工作原理:

template<typename VARIABLE , typename BODY , typename ARG>
struct evaluate_impl<tml::lambda<VARIABLE,BODY>,ARG>
{
    using result = typename tml::lambda<VARIABLE,BODY>::template result<ARG>;
};

我遇到问题的多变量lambda表达式采用了类似的方法:

template<typename... VARIABLES , typename BODY , typename... ARG>
struct evaluate_impl<tml::multi_lambda<BODY,VARIABLES...>,ARGS...>
{
    using result = typename tml::multi_lambda<BODY,VARIABLES...>::template result<ARGS...>;
};

但是不是工作(就像一个变量对应),tml::eval实例化默认evaluate_impl实现的三个案例,或者由于模糊的特化而失败(案例三与特化multi_lambda).

这是一个SSCCE:

//An example function:
template<typename... ARGS>
struct F
{
    using result = std::integral_constant<std::size_t,sizeof...(ARGS)>;
};


//This works fine:

using lambda_1 = tml::lambda<_1,F<_1,_1,_1,_1>>;
using result_1 = tml::eval<lambda_1,int>; //Call the lambda with int as parameter


//This doesn't work:

using lambda_2 = tml::multi_lambda<_1,_2,F<_1,_1,_2,_2>>;
using result_2 = tml::eval<lambda_2,int,int>; //Call the lambda with two int as parameters.

评估lambda_2失败的原因是:

functional.hpp:167:76: error: ambiguous class template instantiation for 'struct tml::impl::evaluate_impl<tml::impl::multi_lambda<tml::placeholders::_1, tml::placeholders::_2, f<tml::placeholders::_1, tml::placeholders::_1, tml::placeholders::_2, tml::placeholders::_2> >, int, int>' using eval = typename impl::evaluate_impl<EXPRESSION , ARGS...>::result; ^ functional.hpp:116:16: error: candidates are: struct tml::impl::evaluate_impl<F<PLACEHOLDERS ...>, ARG, ARGS ...> struct evaluate_impl<F<PLACEHOLDERS...> , ARG , ARGS...> : ^ In file included from main.cpp:24:0: lambda.hpp:160:16: error: struct tml::impl::evaluate_impl<tml::impl::multi_lambda<BODY, VARIABLES ...>, ARGS ...> struct evaluate_impl<multi_lambda<BODY,VARIABLES...>,ARGS...> :

我正在使用GCC4.8.2

Answer 1

首先，你应该真正了解SSCCE到底是什么，尤其是“完整”部分。还有，短。也就是说，我尝试创建一个 SSCCE ，它似乎重现了您的问题，请参阅我的答案末尾。查看您收到的错误消息，似乎您的第三专业化的真实代码看起来更像是

template<template<typename...> class F ,
         typename... PLACEHOLDERS ,
         typename ARG ,
         typename... ARGS>
struct evaluate_impl<F<PLACEHOLDERS...>,ARG,ARGS...>
    : public F<tml::eval<ARG,ARGS>...>
{};

请注意额外明确提及ARG，这似乎是多余的，并且可能会导致您的情况含糊不清。如果你把它替换为

template<template<typename...> class F ,
         typename... PLACEHOLDERS ,
         typename... ARGS>
struct evaluate_impl<F<PLACEHOLDERS...>,ARGS...>
    : public F<tml::eval<ARGS>...>
{};

问题可能就会消失。

最后，这是一个 SSCCE，我曾经遇到过与您类似的错误。

更新：通过下面评论中的 SSCCE，只需禁用专业化即可解决这种F情况foo。条件如下：

typename std::enable_if<!std::is_same<F<>,foo<>>::value>::type

或者查看基于您的 SSCCE 的完整实例。这样，您可能还可以添加ARG回来，因为这两个专业现在应该是互斥的。