改善折叠功能

Improving fold function

本文关键字：功能 折叠      更新时间：2023-10-16

>我在C++中实现了一个简单的折叠函数，它接受一个lambda，并且可以在编译时同时折叠多个向量。我想知道是否可以以某种方式简化它(我提供了递归版本和迭代递归版本 - 我不确定哪个应该有更好的性能(：https://godbolt.org/z/39pW81

性能优化也是受欢迎的 - 在这方面，这两种方法中的任何一种都更快吗？

template<int I, typename type_identity, typename type_head, int N, typename ...type_tail, int ...N_tail,  typename Function>
auto foldHelperR(Function&& func, const type_identity& id, const tvecn<type_head, N>& head, const tvecn<type_tail, N_tail>&... tail)
{
if constexpr (I>0)
{
return func(foldHelperR<I-1>(std::forward<Function>(func), id, head, tail...), head[I], tail[I]...);
}
else
{
return func(id, head[0], tail[0]...);
}
}
template<int I, typename type_identity, typename type_head, int N, typename ...type_tail, int ...N_tail,  typename Function>
auto foldHelperI(Function&& func, const type_identity id, const tvecn<type_head, N>& head, const tvecn<type_tail, N_tail>&... tail)
{
if constexpr (I<N-1)
{
return foldHelperI<I+1>(std::forward<Function>(func), func(id, head[I], tail[I]...), head, tail...);
}
else
{
return func(id, head[N-1], tail[N-1]...);
}
}
template<typename type_identity, typename type_head, int N_head, typename ...type_tail, int ...N_tail, typename Function = void (const type_identity&, const type_head&, const type_tail&...)>
constexpr auto fold(Function&& func, const type_identity& id, const tvecn<type_head, N_head>& head, const tvecn<type_tail, N_tail>&... tail)
{
static_assert(std::is_invocable_v<Function, const type_identity&, const type_head&, const type_tail &...>,
"The function cannot be invoked with these zip arguments (possibly wrong argument count).");
static_assert(all_equal_v<N_head, N_tail...>, "Vector sizes must match.");
//return foldHelperR<N_head-1>(std::forward<Function>(func), id, head, tail...);
return foldHelperI<0>(std::forward<Function>(func), id, head, tail...);
}
int main()
{
tvecn<int,3> a(1,2,3);
return fold([](auto x, auto y, auto z) {return x+y+z;}, 0, a, a);
}

并且可以在编译时同时折叠多个向量

不完全是：如果你想操作编译时

(1(你必须定义constexprtvecn构造函数和

(2(您必须定义constexpr折叠助手函数和

(3(您必须申报constexpra

// VVVVVVVVV
constexpr tvecn<int,3> a(1,2,3);

(4(你必须将折叠的结果放在一个constexpr变量中(或者，更一般地说，放在需要编译时值的地方，作为C样式数组的大小字段，或模板值参数，或static_assert()测试(

constexpr auto f = fold([](auto x, auto y, auto z) {return x+y+z;},
0, a, a);

我想知道是否可以以某种方式简化它

确定。

首先：如果可以的话，避免重新发明weel：你的tvecn是std::array的简化版本。

建议：使用std::array(如果可以的话(

第二：您标记了 C++17，以便您可以使用折叠

建议：也用于all_equal

template <auto V0, auto ... Vs>
struct all_equal : public std::bool_constant<((V0 == Vs) && ...)>
{ };
template<auto ...N_pack>
constexpr bool all_equal_v = all_equal<N_pack...>::value;

更一般地说：当您必须定义必须提供数字的自定义类型特征时，继承(如果可能(来自std::integral_constant(或std::bool_constant，或std::true_type，或std::false_type：所有std::integral_constant专业(。因此，您会自动继承所有std::integral_constant设施。

第三：几乎所有C++标准都使用std::size_t，而不是int，作为尺寸。

建议：当您必须与尺寸有关时，请使用std::size_t，而不是int。这样，您可以避免很多烦人的麻烦。

第四：从main()开始，你应该只返回EXIT_SUCCESS(通常为零(或EXIT_FAILURE(通常为1(

建议：避免将事情作为

return fold([](auto x, auto y, auto z) {return x+y+z;}, 0, a, a);

第五：永远不要低估逗号运算符的力量。

建议：完全避免递归，并将模板折叠也用于辅助函数;通过示例

template <std::size_t ... Is, typename F, typename T, typename ... As>
constexpr auto foldHelperF (std::index_sequence<Is...>,
F const & f, T id, As const & ... arrs)
{ return ( ..., (id = [&](auto i){ return f(id, arrs[i]...); }(Is))); }

您可以从fold()调用如下

return foldHelperF(std::make_index_sequence<N_head>{}, 
std::forward<Function>(func),
id, head, tail...);

以下是完整编译和简化的示例

#include <array>
#include <utility>
#include <iostream>
#include <type_traits>
template <auto V0, auto ... Vs>
struct all_equal : public std::bool_constant<((V0 == Vs) && ...)>
{ };
template<auto ...N_pack>
constexpr bool all_equal_v = all_equal<N_pack...>::value;

template <std::size_t ... Is, typename F, typename T, typename ... As>
constexpr auto foldHelperF (std::index_sequence<Is...>,
F const & f, T id, As const & ... arrs)
{ return ( ..., (id = [&](auto i){ return f(id, arrs[i]...); }(Is))); }

template <typename type_identity, typename type_head, std::size_t N_head,
typename ...type_tail, std::size_t ...N_tail,
typename Function = void (type_identity const &,
type_head const &,
type_tail const & ...)>
constexpr auto fold (Function && func, type_identity const & id,
std::array<type_head, N_head> const & head,
std::array<type_tail, N_tail> const & ... tail)
{
static_assert( std::is_invocable_v<Function, const type_identity&,
const type_head&, const type_tail &...>,
"The function cannot be invoked with these zip arguments"
" (possibly wrong argument count).");
static_assert( all_equal_v<N_head, N_tail...>,
"Vector sizes must match.");
return foldHelperF(std::make_index_sequence<N_head>{}, 
std::forward<Function>(func),
id, head, tail...);
}
int main()
{
constexpr std::array<int, 3u> b{2, 5, 7};
constexpr auto f = fold([](auto x, auto y, auto z) {return x+y+z;},
0, b, b);
std::cout << f << std::endl;
}

使用折叠表达式，它可能是：

template <typename F, typename Init, std::size_t... Is, typename... Arrays>
constexpr auto fold_impl(F&& f, Init init, std::index_sequence<Is...>, Arrays&&... arrays)
{
auto l = [&](Init init, std::size_t i){ return f(init, arrays[i]...); };
return ((init = l(init, Is)), ...);
}

template <typename F, typename Init, typename Array, typename ... Arrays>
constexpr auto fold(F&& f, Init init, Array&& array, Arrays&&... arrays)
{
static_assert(((arrays.size() == array.size()) && ...));
return fold_impl(f, init, std::make_index_sequence<array.size()>{}, array, arrays...);
}

演示

相关文章：