c++ - 基于部分模板-模板的特化与显式部分模板的特化

给定一个模板，例如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...>>
{};

第二部分特化不是比第一部分特化更专业并且必须实例化而不是template-template参数专门化吗？

一些背景:

我目前正在为基于this paper的模板元编程编写多变量lambda表达式。

如论文所示，给定类似Haskell的let表达式，可以轻松开发tmp lambda表达式。就我而言，我扩展了本文的内容，开发了基于可变参数模板的多变量let表达式(通过 curry 化多个嵌套的一元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(有关更多上下文，请参见my previous question)。

评估函数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实例化通用模板-模板专用化(为通用可评估表达式设计)，而不是lambda的部分专用化。

编辑:tml::eval和SSCCE的实现
tml::eval是一个元函数，设计用于评估任何一种表达式，并返回结果。默认实现专门针对以下三种情况:

表达式不是函数，仅是值:评估这种表达式的结果是表达式本身:

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

表达式是一个函数:求值结果是该函数的result成员类型的值。函数的参数也会被求值(以处理嵌套表达式):

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

表达式是一个函数，并且有更多的参数传递给tml::eval来使用该自定义参数对表达式求值:表达式的参数将被忽略，并且自定义参数将被传递和求值:

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

最佳答案

首先，您应该真正了解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>...>
{};

问题可能会消失。

最后，here's an SSCCE我曾经遇到过与您类似的错误。

更新:使用以下注释中的SSCCE，可以通过在F禁用foo的特殊化的情况下简单地解决这种情况。条件看起来像这样:

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

或根据您的SSCCE查看完整的live example。这样，您可能还可以添加ARG，因为这两个专业现在应该互斥了。