在一行中使用两个折叠表达式

Question

我正在学习C++折叠表达式,他们非常适合扩展一个参数包.但是,如果我必须在一次通话中扩展其中一些呢？

我准备了一个例子来澄清我的意思:

#include <cstddef>
#include <iostream>
#include <utility>

template<
    template<size_t ix_, size_t iy_> typename Functor,
    typename FunctorContext,
    size_t... ix,
    size_t... iy>
void RepeatImpl(
    FunctorContext* context,
    std::index_sequence<ix...>,
    std::index_sequence<iy...>)
{
    (Functor<ix, iy>::Execute(context), ...);
}

template<
    template<size_t ix_, size_t iy_> typename Functor,
    size_t width, size_t height,
    typename FunctorContext>
void Repeat(FunctorContext* context)
{
    RepeatImpl<Functor>(
        context,
        std::make_index_sequence<width>(),
        std::make_index_sequence<height>());
}

template<size_t ix, size_t iy>
struct Init2dArrayFunctor
{
    template<typename T>
    static void Execute(T* array)
    {
        array[iy][ix] = 10;
    }
};

int main(int, const char**)
{
    constexpr size_t w = 10;
    constexpr size_t h = 10;
    int array[w][h] { 0 };
    Repeat<Init2dArrayFunctor, w, h>(array);

    for(size_t iy = 0; iy < h; ++iy)
    {
        for(size_t ix = 0; ix < w; ++ix)
        {
            std::cout << array[iy][ix] << ' ';
        }

        std::cout << std::endl;
    }

    return 0;
}

我的问题是关于这一行:

(Functor<ix, iy>::Execute(context), ...);

在这个特定的例子中,它将扩展到这些调用:

Functor<0, 0>::Execute(context)
Functor<1, 1>::Execute(context)
Functor<2, 2>::Execute(context)
...

但我需要它来调用ix和iy包的所有组合:

Functor<0, 0>::Execute(context)
Functor<0, 1>::Execute(context)
Functor<0, 2>::Execute(context)
...
Functor<1, 0>::Execute(context)
Functor<1, 1>::Execute(context)
Functor<1, 2>::Execute(context)
...

我知道我可以做一个额外的层来遍历行和列(然后在单独的方法中使用两个折叠表达式):

#include <cstddef>
#include <iostream>
#include <utility>


template<
    template<size_t ix_, size_t iy_> typename Functor,
    size_t iRow,
    typename FunctorContext,
    size_t... iColumn>
void RepeatImpl_Row(
    FunctorContext* context,
    std::index_sequence<iColumn...>)
{
    (Functor<iColumn, iRow>::Execute(context), ...);
}

template<
    template<size_t ix_, size_t iy_> typename Functor,
    size_t columns,
    typename FunctorContext,
    size_t... iRow>
void RepeatImpl(
    FunctorContext* context,
    std::index_sequence<iRow...>)
{
    (RepeatImpl_Row<Functor, iRow>(context, std::make_index_sequence<columns>()), ...);
}

template<
    template<size_t ix_, size_t iy_> typename Functor,
    size_t width, size_t height,
    typename FunctorContext>
void Repeat(FunctorContext* context)
{
    RepeatImpl<Functor, width>(
        context,
        std::make_index_sequence<height>());
}

template<size_t ix, size_t iy>
struct Init2dArrayFunctor
{
    template<typename T>
    static void Execute(T* array)
    {
        array[iy][ix] = 10;
    }
};

int main(int, const char**)
{
    constexpr size_t w = 10;
    constexpr size_t h = 10;
    int array[w][h] { 0 };
    Repeat<Init2dArrayFunctor, w, h>(array);

    for(size_t iy = 0; iy < h; ++iy)
    {
        for(size_t ix = 0; ix < w; ++ix)
        {
            std::cout << array[iy][ix] << ' ';
        }

        std::cout << std::endl;
    }

    return 0;
}

但这种方式使代码更难阅读.也许有可能在一行中使用两个折叠表达式来做这个技巧吗？

Answer 1

你可以简单地写一些类似的东西：

template<
    size_t height,
    template<size_t ix_, size_t iy_> typename Functor,
    typename FunctorContext,
    size_t... ixy>
void RepeatImpl(
    FunctorContext* context,
    std::index_sequence<ixy...>)
{
    (Functor< ixy / height, ixy % height >::Execute(context), ...);
}

template<
    template<size_t ix_, size_t iy_> typename Functor,
    size_t width, size_t height,
    typename FunctorContext>
void Repeat(FunctorContext* context)
{
    RepeatImpl<height,Functor>(
        context,
        std::make_index_sequence<width*height>() );
}

当我们有可变参数类型而不是索引时它会起作用吗？

在这种情况下，只需将类型列表包装在可索引类型元组中即可。

但是有没有办法通过折叠来处理一些可变参数？

就目前而言，不，我认为这是不可能的；包始终线性扩展，如果存在多个包，它们会同时扩展并且必须具有相同的长度，正如您已经观察到的那样。我们没有对“power-product”包扩展的“直接”语言支持。如果您想要一对模板参数的笛卡尔积，您总是会得到类似上面的结果......