首页 文章

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

提问于
浏览
5

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

Is not the second partial specialization more specialized than the first and must be instanced instead of the template-template parameter specialization?

一些背景:

我目前正在为基于this paper的模板元编程编写多变量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 (有关更多上下文,请参阅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 实例化通用模板模板特化(专为通用可评估表达式设计)而不是lambdas的部分特化 .

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

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

  • The expression is not a function, is a value only :评估此类表达式的结果是表达式本身:
template<typename E>
struct evaluate_impl<E>
{
    using result = E;
};
  • The expression is a function :评估结果是函数的 result 成员类型的值 . 函数的参数也被评估(为了处理嵌套表达式):
template<template<typename...> class F , typename... ARGS>
struct evaluate_impl<F<ARGS...>> : public F<tml::eval<ARGS>...>
{};
  • The expression is a function, and more argumments are passed to tml::eval to evaluate the expression with that custom 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

2 回答

  • 0

    首先,你应该真正了解SSCCE究竟是什么,特别是 "complete" 部分 . 另外, short . 也就是说,我试图创建一个似乎可以重现你的问题的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,我曾经得到一个类似的错误比你 .


    Update: 通过下面的评论中的SSCCE,可以通过在 foo 时禁用 F 的特化来解决这种情况 . 条件如下:

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

    或根据您的SSCCE查看完整的live example . 通过这种方式,您可能还可以添加 ARG ,因为两个专业化现在应该是互斥的 .

  • 1

    看起来在你的multi_lambda中你最后用变量......声明了模板 .

    template<typename BODY , typename... VARIABLES>
    struct multi_lambda
    {
        //...
    };
    

    也许在你的使用中你应该使用:

    using lambda_2 = tml::multi_lambda<F<_1,_1,_2,_2>,_1,_2>;
    

相关问题