我写了以下代码:

#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函数基于对另一个问题的回答。

我正在编译带有标志符

——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
}