4

我有一个自定义类，它有一个类似元组的接口。因为我希望我的代码尽可能通用，所以我认为将我的算法基于函数std::get,是一个好主意std::tuple_size，std::tuple_element因此您只需专门化这些函数即可使用我的算法。让我们将需要这些函数特化的概念称为Tuple。

现在我试图总结 a 的组成部分Tuple。函数声明应该是这样的：

template <class Tuple>
int sum_components(const Tuple& t);

我想这涉及到很多模板编程，但我就是不知道该怎么做。

除此之外，我只会使用全局的重载+ operator。

我正在使用 c++1z。

4

2 回答 2

12

中非常容易。

template<class Tuple>
decltype(auto) sum_components(Tuple const& tuple) {
  auto sum_them = [](auto const&... e)->decltype(auto) {
    return (e+...);
  };
  return std::apply( sum_them, tuple );
};

或(...+e)相反的折叠方向。

在以前的版本中，正确的方法是编写自己的apply而不是编写定制的实现。当您的编译器更新时，您可以删除代码。

在中，我可能会这样做：

// namespace for utility code:
namespace utility {
  template<std::size_t...Is>
  auto index_over( std::index_sequence<Is...> ) {
    return [](auto&&f)->decltype(auto){
      return decltype(f)(f)( std::integral_constant<std::size_t,Is>{}... );
    };
  }
  template<std::size_t N>
  auto index_upto() {
    return index_over( std::make_index_sequence<N>{} );
  }
}
// namespace for semantic-equivalent replacements of `std` code:
namespace notstd {
  template<class F, class Tuple>
  decltype(auto) apply( F&& f, Tuple&& tuple ) {
    using dTuple = std::decay_t<Tuple>;
    auto index = ::utility::index_upto< std::tuple_size<dTuple>{} >();
    return index( [&](auto...Is)->decltype(auto){
      auto target=std::ref(f);
      return target( std::get<Is>( std::forward<Tuple>(tuple) )... );
    } ); 
  }
}

这非常接近 14 std::apply。（我滥用以获得语义）。（它不适用于右值调用程序，但这是非常极端的情况）。std::refINVOKE

在中，我建议此时升级你的编译器。在中，我建议此时升级你的工作。

以上所有都做右或左折叠。在某些情况下，二叉树折叠可能会更好。这更棘手。

如果您的+do 表达式模板，由于生命周期问题，上述代码将无法正常工作。在某些情况下，您可能必须为“之后，强制转换”添加另一种模板类型以使临时表达式树进行评估。

于 2016-11-22T18:30:38.137 回答
7

在 C++1z 中，折叠表达式非常简单。首先，将元组转发给一个_impl函数并为其提供索引序列以访问所有元组元素，然后求和：

template<typename T, size_t... Is>
auto sum_components_impl(T const& t, std::index_sequence<Is...>)
{
    return (std::get<Is>(t) + ...);
}

template <class Tuple>
int sum_components(const Tuple& t)
{
    constexpr auto size = std::tuple_size<Tuple>{};
    return sum_components_impl(t, std::make_index_sequence<size>{});
}

演示

C++14 方法是递归地对可变参数包求和：

int sum()
{
    return 0;
}

template<typename T, typename... Us>
auto sum(T&& t, Us&&... us)
{
    return std::forward<T>(t) + sum(std::forward<Us>(us)...);
}

template<typename T, size_t... Is>
auto sum_components_impl(T const& t, std::index_sequence<Is...>)
{
    return sum(std::get<Is>(t)...);
}

template <class Tuple>
int sum_components(const Tuple& t)
{
    constexpr auto size = std::tuple_size<Tuple>{};
    return sum_components_impl(t, std::make_index_sequence<size>{});
}

演示

C++11 方法是具有自定义实现的 C++14 方法index_sequence。例如从这里。

正如@ildjarn 在评论中指出的那样，上面的示例都使用了右折叠，而许多程序员希望在他们的代码中使用左折叠。C++1z 版本是微不足道的：

template<typename T, size_t... Is>
auto sum_components_impl(T const& t, std::index_sequence<Is...>)
{
    return (... + std::get<Is>(t));
}

演示

而 C++14 也差不了多少，但还有更多变化：

template<typename T, typename... Us>
auto sum(T&& t, Us&&... us)
{
    return sum(std::forward<Us>(us)...) + std::forward<T>(t);
}

template<typename T, size_t... Is>
auto sum_components_impl(T const& t, std::index_sequence<Is...>)
{
    constexpr auto last_index = sizeof...(Is) - 1;
    return sum(std::get<last_index - Is>(t)...);
}

演示

于 2016-11-20T02:56:37.810 回答