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

我正在学习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;
}

但是这种方式使代码更难阅读。
也许可以用一行中的两个折叠表达式来完成这个技巧？

最佳答案

您可以简单地编写如下内容:

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>() );
}

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



到目前为止，不，我认为这是不可能的；包总是线性扩展，并且如果存在多个包，则它们将同时扩展，并且长度必须与您已经观察到的相同。我们不支持“动力产品”包装扩展的“直接”语言支持。如果要使用一对模板参数的笛卡尔乘积，则总会得到与上述类似的结果...

关于c++ - 在一行中使用两个折叠表达式，我们在Stack Overflow上找到一个类似的问题：https://stackoverflow.com/questions/47549657/