使用`std::integer_sequence`编译时间嵌套循环

Question

在下面的代码中，我制定了一个编译时嵌套循环，它调用一个将数字打印到屏幕的print 函数。 1D 和 2D 版本工作，但 3D 版本触发 note: candidate template ignored: failed template argument deduction 错误。我做错了什么？

#include <functional>
#include <iostream>


// 1D processing.
template<int I>
constexpr void print()
{
    std::cout << I << std::endl;
}


template<int... Is>
constexpr void test(
        std::integer_sequence<int, Is...> is)
{
    (print<Is>(), ...);
}
// End 1D.


// 2D processing.
template<int I, int J>
constexpr void print()
{
    std::cout << I << ", " << J << std::endl;
}


template<int I, int... Js>
constexpr void print(
        std::integer_sequence<int, Js...> js)
{
    (print<I, Js>(), ...);
}


template<int... Is, int... Js>
constexpr void test(
        std::integer_sequence<int, Is...> is,
        std::integer_sequence<int, Js...> js)
{
    (print<Is, Js...>(js), ...);
}
// End 2D.


// 3D processing.
template<int I, int J, int K>
constexpr void print()
{
    std::cout << I << ", " << J << ", " << K << std::endl;
}

template<int I, int J, int... Ks>
constexpr void print(
        std::integer_sequence<int, Ks...> ks)
{
    (print<I, J, Ks>(), ...);
}


template<int I, int... Js, int... Ks>
constexpr void print(
        std::integer_sequence<int, Js...> js,
        std::integer_sequence<int, Ks...> ks)
{
    (print<I, Js, Ks...>(ks), ...);
}


template<int... Is, int... Js, int... Ks>
constexpr void test(
        std::integer_sequence<int, Is...> is,
        std::integer_sequence<int, Js...> js,
        std::integer_sequence<int, Ks...> ks)
{
    // THIS CALL FAILS DURING COMPILATION.
    (print<Is, Js..., Ks...>(js, ks), ...);
}
// End 3D.


int main()
{
    constexpr std::integer_sequence<int, 1, 2, 4, 8> is{};
    constexpr std::integer_sequence<int, 1, 2, 4> js{};
    constexpr std::integer_sequence<int, 32, 64> ks{};

    test(is); // 1D example.
    test(is, js); // 2D example.
    test(is, js, ks); // 3D example, FAILS.

    return 0;
}

Answer 1

它失败的原因是你的函数print 的重载需要三个模板参数有两个可变参数模板参数包 template<int I, int... Js, int... Ks>。多个模板参数包只有在编译器可以从函数参数中扣除它们时才有效（参见temp.param/14）：

函数模板的模板形参包后面不应有另一个模板形参，除非该模板形参可以从函数模板的形参类型列表 ([dcl.fct]) 推导出来或具有默认实参 ( [温度扣除]）。 没有默认参数的演绎指南模板（[temp.deduct.guide]）的模板参数应可从演绎指南模板的参数类型列表中推导出来。

当显式指定模板参数时，编译器将因此贪婪地将它们匹配到第一个参数包。 即使combining type and non-type parameters 也是如此。只有这样从非模板函数参数中进行推导。

这意味着in your case

(print<Is, Js..., Ks...>(js, ks), ...);

实际上会忽略希望的候选模板

prog.cc:64:16: note: candidate template ignored: failed template argument deduction

有点像

print<I, Js..., Ks...>()

实际上会匹配类似的东西

template <int I, int... Ts>
constexpr void print()

Js... 和 Ks... 将合并为 Ts... = {Js..., Ks...} 将没有任何指定的模板参数留给以下包 - 按照标​​准 - 必须可以从非模板函数参数中推导出它们。

---

为了了解为什么在初始代码中允许这样的语法可能会出现问题，只需想象一个具有两个参数包 Ts 和 Ss 的模板函数，其中 Ss 可以从函数参数中扣除，但 @987654337 @ 不能被扣除，而是必须明确指定，

template <typename... Ts, typename... Ss>
void func(Ss... ss) {
  return;
}

被调用的

func<int,double>(int{1}, double{7.0});

这将是模棱两可的（Ts = {int, double}, Ss = {int, double} 或 Ts = {}, Ss = {int, double}），因此会导致初始代码中的逻辑出现问题，但如果您贪婪地匹配参数，然后才从函数中扣除，则它是明确的（Ts = {int, double}, Ss = {int, double}）论据。

---

在您的情况下，只需 删除最右边的参数包

(print<Is, Js...>(js, ks), ...);

或两者都有

(print<Is>(js, ks), ...);

使编译成功，因为Js和Ks都可以从函数参数js和ks中扣除。 Try it here!