编译可变参数模板时 GCC 5.3.1 C++ 停止

Posted 2023-02-22

【中文标题】编译可变参数模板时 GCC 5.3.1 C++ 停止

【英文标题】：GCC 5.3.1 C++ Stalls When Compiling Variadic Template

【发布时间】：2016-06-28 06:54:59

【问题描述】：

我写了以下代码：

#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 数组来保存系数来进行所需的计算。

所有未列出的函数都出现在单独的头文件中，并且编译没有问题。

我正在尝试使用“indicies”技巧来使用基于this answer to another question 的 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];

这段代码 sn-p 也重现了这个问题，这让我相信它与 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

【问题讨论】：

您尝试过使用最近的 Clang（3.7 或 3.8）还是 GCC6 编译器？

能否至少提供缺失函数的声明（无主体）以便我们编译？

要回显@Holt，没有power 等，您显示的代码没有 有用。见sscce.org。

我不是 100% 确定，但由于 gen_seq 的终止条件是 N = 0，您的序列中可能有一个 0，因此您将调用 coeff(0)将在我的架构上调用power(-1, ((size_t)0) - 1)，即power(-1, 18446744073709551615)，这显然永远不会编译。

@AlexZywicki 请参阅我的（现已编辑）答案，了解有关为什么您的代码未编译以及如何修复所有问题的指示。

【参考方案1】：

如何修复您的代码？

您在这里缺少const 限定符：

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

您的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 的方式（感谢 @T.C.，请参阅 cmets）：

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

您不应该使用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（在我的架构上）——如果你用factorial 溢出std::intmax_t（多么好的编译器！），Clang 会在编译时警告你。

通过上述两个修改，您的代码可以正常工作（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 结构基本上是std::size_t... 的结构持有者（因为您不能将其直接存储在变量中）。

gen_seq 是一个“递归”结构，它使用gen_seq<N - 1, ...> 构建gen_seq<N, ...>。它是如何工作的：

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>) 时，您允许编译器推导出_coeffs 的模板参数NS。由此，你可以在_coeffs中使用NS来做pack expansion：

coeff(NS)...;

【讨论】：

我会尽快完成这些更改。另一方面，我计划将“max_factorial”实现为一个函数，该函数执行编译时检查，以检测给定系统上的阶乘溢出在哪个 N 处，希望使其更具可移植性。

@AlexZywicki 你可以在double 上而不是std::intmax_t 上做一个阶乘，这将允许你去更大的阶乘（你可以用双倍提高到factorial(170)）。您也可以尝试对数字的倒数进行“阶乘”，例如1/1 * 1/2 * 1/3 * 1/4 * ... 而不是 1/(1 * 2 * 3 * ...)，你可能会得到更好的准确度（没有测试想法，我不是 100% 确定）。

我会试试看的！我有兴趣看看这是否会产生正确的结果。这将使我能够显着提高泰勒级数的准确性

我认为gen_seq 写得正确，但使用不正确。

或者改用coeff(NS + 1) ...。