GCC 5.3.1 C++在编译可变参数模板时失速

Question

我写了以下代码:

#include<array>
#include<type_traits>

namespace math{
    namespace detail{

        template<std::size_t... Is> struct seq{};

        template<std::size_t N, std::size_t... Is>
        struct gen_seq : gen_seq<N-1, N-1, Is...>{};

        template<std::size_t... Is>
        struct gen_seq<0, Is...> : seq<Is...>{};

        template<class T,std::size_t N>
        struct sin_coeffs{
            using array_type = std::array<T,N>;
            constexpr static inline T coeff(std::size_t n){
                return power(-1, n-1) * inverse((T)factorial((2 * n)-1));
            }
            template<std::size_t...NS>
            constexpr static array_type _coeffs(seq<NS...>){
                return {{coeff(NS)...}};
            }
            constexpr static array_type coeffs=_coeffs(gen_seq<N>{});
        };
    }

    template<class T,std::size_t N = max_factorial, class dcy = std::decay_t<T>>
    constexpr std::enable_if_t<std::is_floating_point<dcy>::value,dcy> sin(T x) noexcept{
        constexpr std::array<dcy,N>& coeffs = detail::sin_coeffs<dcy,N>::coeffs;
        const dcy x_2 = x*x;
        dcy pow = x;
        dcy result = 0;
        for(std::size_t i=0;i<N;++i){
            result += coeffs[i] * pow;
            pow*=x_2;
        }
        return result;
    }
}

示例主要:

int main()
{
    constexpr double d = math::sin(0.0);
}

该代码被设计为constexpr sin函数,该函数使用constexpr数组来保存系数以进行所需的计算.

未列出的所有函数都存在于单独的头文件中,编译没有问题.

我试图使用"指标"技巧来填充数组使用constexpr函数根据另一个问题的答案.

我正在用GCC 5.3.1编译标志

--std = c ++ 1z -pthread -g -O3 -MMD -MP -Wall -pedantic

编译器不会向我的代码发出错误,但在编译时会停顿.

我让编译运行了几分钟,但它没有做任何事情.

我已经测试了代码中使用的所有函数,它们都可以独立于本节编译.

int main()
{
    math::detail::sin_coeffs<double,20>::coeffs[0];
}

这段代码片段也重现了这个问题,这使我相信它与sin函数本身无关,而与sin_coeffs结构有关.

编辑:以下是其他要求的功能:

#include <type_traits>
namespace math{

    template<class T,class dcy = std::decay_t<T>>
    constexpr inline std::enable_if_t<std::is_floating_point<T>::value,dcy> inverse(T value){
        return (value == 0) ? 0.0 : 1.0 / value;
    }
    template <class T>
    constexpr inline std::decay_t<T> sign(T value) {
        return value < 0 ? -1 : 1;
    }
    template <typename T>
    constexpr inline std::decay_t<T> abs(T value) {
        return value * sign(value);
    }
    template<class T>
    constexpr inline std::decay_t<T> power(T const& base, std::size_t const& pow){
        if(pow==0){return 1;}
        else if(pow == 1){return base;}
        else{
            T result = base;
            for(std::size_t i=1;i<pow;++i){
                result*=base;
            }
            return result;
        }
    }
    constexpr std::intmax_t factorial(std::intmax_t const& n){
        if(n==0){return 1;}
        std::intmax_t result = n;
        for(std::intmax_t i=n-1;i>0;--i){
            result *=i;
        }
        return result;
    }
    constexpr static std::size_t max_factorial = 20;//replace with calculated version later
}

Answer 1

如何修复你的代码？

1. 你在const这里错过了一个限定符:

constexpr const std::array<dcy,N>& coeffs = /* ... */ ;
          ^^^^^

2. 你gen_seq从生成值0到N - 1,但关于你的coeff功能,你想从价值观1到N.您可以通过以下方式解决此问题

• 更改基本模板根据值生成1到N(见这个答案详细解释的底部):

template<std::size_t N, std::size_t... Is>
struct gen_seq: gen_seq<N-1, N, Is...> {};
//                           ^--- N instead of N - 1

• 改变你调用coeff的方式(感谢@TC,见评论):

template<std::size_t...NS>
constexpr static array_type _coeffs(seq<NS...>){
    return {{coeff(NS + 1)...}};
//                   ^^^^
}

3. 您不应该使用power计算-1 ** n,使用三元条件:

constexpr static inline T coeff(std::size_t n){
    return (n%2 ? 1 : -1) * inverse((T)factorial((2 * n)-1));
}

有了这个,我可以计算系数:

auto arr = math::detail::sin_coeffs<double, 10>::coeffs;
for (auto x: arr) {
    std::cout << x << " ";
}

输出:

1 -0.166667 0.00833333 -0.000198413 2.75573e-06 -2.50521e-08 1.6059e-10 -7.64716e-13 ...

据我所知,这些都是正确的系数(1,-1/3!,1/5!,...).请注意,我不得不使用N = 10,或者我会溢出std::intmax_t(在我的体系结构) -锵警告你,如果你溢出编译时std::intmax_t使用factorial(多么编译器!).

通过以上两个修改,您的代码工作正常(除了max_factorial值,但您可以根据需要调整它).

请参阅以下代码rextester:http://rextester.com/CRR35028

您的代码中的主要问题是什么？

你gen_seq<N>生成的序列从0到N - 1,所以你打电话了coeff(0),这是呼唤power(-1, static_cast<size_t>(0) - 1),这实际上是power(-1, 18446744073709551615)(我的架构),它不能编译.添加一个简单的案例来power"修复"编译(显示这是一个问题,但没有解决真正的问题):

template<class T>
constexpr inline std::decay_t<T> power(T const& base, std::size_t const& pow) {
    if (pow == static_cast<size_t>(0) - 1) { // Stupid test
      return 1;
    }
    /* ... */
}

而且,你的max_factorial价值也可能太大了.在更正后power,我无法编译max_factorial > 11(我可能有32位,std::intmax_t所以你可能超过这个,但我认为20在所有情况下都太大了).

此外,对于未来的问题,clang似乎提供了更好的信息,为什么它不编译:

• 它对迭代次数有限制,所以我能够发现它power正在进行(几乎)无限循环.
• 它为factorial溢出的返回值发出警告intmax_t.

gen_seq诀窍是如何运作的？

你的seq结构基本上是a的结构持有者std::size_t...(因为你不能将它直接存储在变量中).

这gen_seq是一个gen_seq<N, ...>使用构建的"递归"结构gen_seq<N - 1, ...>.它是如何工作的:

gen_seq<3>: gen_seq<2, 2>
gen_seq<2, 2>: gen_seq<1, 1, 2>
gen_seq<1, 1, 2>: gen_seq<0, 0, 1, 2>
gen_seq<0, 0, 1, 2>: seq<0, 1, 2> // Specialized case

正如您所看到的,自从您继承之后gen_seq<N - 1, N - 1, ...>,最后一次继承seq具有0您不想要的值.由于什么是"发送" seq是可变参数std::size_t...,你想避免拥有0,所以你改为gen_seq<N - 1, N, ...>:

gen_seq<3>: gen_seq<2, 3>
gen_seq<2, 3>: gen_seq<1, 2, 3>
gen_seq<1, 2, 3>: gen_seq<0, 1, 2, 3>
gen_seq<0, 1, 2, 3>: seq<1, 2, 3> // Specialized case

现在,当你打电话_coeffs(gen_seq<N>{}),你让编译器推断模板实参NS的_coeffs.从这里,您可以使用NSin _coeffs来进行包扩展:

{{coeff(NS)...}};