Question

我正在尝试执行一个总模板特化，如果suffixTry其他什么都不做（终止条件），那么它应该执行第一个代码块（i > -1）。我不太清楚应该如何编写最后一个suffixTry模板。编译时，编译器指向范围中的-1 is unknown。

template< typename S ,typename I >
void suffixTry(S pattern, I suff[], I size, I f, I g, I i) {
    suff[size - 1] = size;

    if (i > g && suff[i + size - 1 - f]  < i - g){
        suff[i] = suff[i + size - 1 - f];
    } else {
        if (i < g)
            g = i;

        f = i;
        reduceToZero(pattern, g, size, f);
        suff[i] = f - g;
    }

    suffixTry(pattern, suff, size, f, g, --i);
}

template< typename S ,typename I>
void  suffixTry(S pattern, I suff[], I size, I f, I g, -1) {

}

Answer 1

从你的代码看来，你似乎只想要简单的递归：

template< typename S ,typename I >
void  suffixTry(S pattern, I suff[], I size, I f, I g, I i   ) {
    // base case:
    if (i == -1) {
        return;
    }

    suff[size-1]=size;

    if( i > g && suff[i + size - 1 - f]  < i -g ){
        suff[i] = suff[i+size-1-f];
    }
    else{
        if ( i < g)
            g = i;

        f=i;
        reduceToZero(pattern , g,size,f);
        suff[i] = f - g ;

     }
     suffixes(pattern,suff, size, f , g ,  --i);

}

Answer 2

您无法对常规参数进行专业化，仅对模板参数进行专业化。

所以它需要：

template<typename S, typename I, I i>
void suffixTry(S pattern, I suff[], I size, I f, I g);

但是你不能对功能进行部分专业化，所以你必须引入一个struct。另外，i不能依赖I进行部分专精化，因此我改为使用int。

template<typename S, typename I, int i>
struct suffixTry
{
    void operator () (S pattern, I suff[], I size, I f, I g) const
    {
        suff[size - 1]=size;

        if (i > g && suff[i + size - 1 - f]  < i - g) {
            suff[i] = suff[i + size - 1 - f];
        } else {
            if (i < g)
                g = i;
            f = i;
            reduceToZero(pattern, g, size, f);
            suff[i] = f - g ;
        }
        suffixTry<S, I, i - 1>()(pattern, suff, size, f , g);

    }
};

template<typename S, typename I>
struct suffixTry<S, I, -1>
{
    void operator () (S pattern, I suff[], I size, I f, I g) const {}
};

但在运行时进行检查似乎更简单/更清楚：

template <typename S, typename I>
void suffixTry(S pattern, I suff[], I size, I f, I g, I i) {
    if (i == -1) {
        return;
    }
    suff[size - 1] = size;

    if (i > g && suff[i + size - 1 - f]  < i - g){
        suff[i] = suff[i + size - 1 - f];
    } else {
        if (i < g)
            g = i;

        f = i;
        reduceToZero(pattern, g, size, f);
        suff[i] = f - g;
    }

    suffixTry(pattern, suff, size, f, g, --i);
}

按值（-1）

2 个答案: