优雅的模板专业化

有没有一种优雅的方法来基于其模板参数之一专门化模板？

IE浏览器.

template struct Junk {
    static int foo() {
        // stuff
        return Junk::foo();
    }
};

// compile error: template argument '(size * 5)' involves template parameter(s)
template struct Junk {
    static int foo() {
        // stuff
        return N;
    }
};

template<> struct Junk<0> {
    static int foo() {
        // stuff
        return 0;
    }
};

IE浏览器.我试图专门化一个基于参数可被5整除的模板.我似乎可以这样做的唯一方法如下:

template struct JunkDivisibleBy5 {
    static int foo() {
        // stuff
        return N;
    }
};

template struct Junk {
    static int foo() {
        // stuff
        if ((N - 1) % 5 == 0 && N != 1)
            return JunkDivisibleBy5::foo();
        else
            return Junk::foo();
    }
};


template<> struct Junk<0> {
    static int foo() {
        // stuff
        return 0;
    }
};

但这显然不那么优雅,并且即使模板参数不需要它也需要实例化所有模板.

这个怎么样:

#include 
using namespace std;

template < typename T, T N, T D >
struct fraction {
    typedef T value_type;
    static const value_type num = N;
    static const value_type denom = D;
    static const bool is_div = (num % denom == 0);
};

template< typename T, T N, T D, bool P >
struct do_if {
    static void op() { cout << N << " NOT divisible by " << D << endl; }
};

template< typename T, T N, T D >
struct do_if< T, N, D, true > {
    static void op() { cout << N << " divisible by " << D << endl; }
};

template < int N >
void foo() {
    typedef fraction< int, N, 5 > f;
    do_if< typename f::value_type, f::num, f::denom, f::is_div >::op();
}

int main() {
    foo< -5 >();
    foo< -1 >();
    foo< 0 >();
    foo< 1 >();
    foo< 5 >();
    foo< 10000005 >();
    return 0;
}

使用D编程语言模板,可以将其写为:

struct Junk(int N)
{
    static int foo()
    {
        static if (N == 0)
            return 0;
        else static if ((N % 5) == 0)
            return N;
        else
            return Junk!(N - 1).foo();
    }
}

静态if在编译时执行.

所有计算都可以在编译时进行:

#include 

template struct Junk {
    enum { IsDivisibleBy5 = (N % 5 == 0) };
    template struct JunkInternal {
        enum { Result = Junk::Result };
    };
    template<> struct JunkInternal {
        enum { Result = N };
    };
    enum { Result = JunkInternal::Result };
};

int main(int, char**)
{
    std::cout << Junk< 0 >::Result << std::endl;
    std::cout << Junk< 7 >::Result << std::endl;
    std::cout << Junk< 10 >::Result << std::endl;

    return 0;
}