purecpp - a cool open source modern c++ community

实现一个trivially_copyable的tuple

编辑时间：2022-08-27 10:10:04 作者：qicosmos 1条评论

出自：purecpp.cn

转载请注明出处！

trivially_copyable类型是指可以安全的使用std::memcpy将对象拷贝到一个二进制buffer的类型。

std::tuple<Args...>不是trivially_copyable类型，标准并没有对tuple的实现做约束，很多编译器实现tuple的时候用了一个buffer和placement new来存储内部的元素，这种实现方式就不可避免的使用copy/move 构造函数，这导致了std::tuple不是一个trivially_copyable类型，这在很多时候没办法做性能优化, 在之前的文章里讲到过这种场景。

因此，有必要实现一个trivially_copyable的tuple以满足性能优化的需要。

实现一个简单的trivially_copyable的tuple

```c++
template <size_t I, typename T> struct element_holder {
  using type = T;
  T value;
};

template <typename Sequence, typename... Ts> struct tuple_impl;

template <typename... Ts, size_t... Is>
struct tuple_impl<std::index_sequence<Is...>, Ts...>
    : element_holder<Is, Ts>... {
  tuple_impl() = default;
  tuple_impl(Ts &&...ts) : element_holder<Is, Ts>{std::forward<Ts>(ts)}... {}
};

template <typename... Ts>
struct tuple : tuple_impl<std::make_index_sequence<sizeof...(Ts)>, Ts...> {
  using base = tuple_impl<std::make_index_sequence<sizeof...(Ts)>, Ts...>;
  using base::base;
};

template <size_t I, typename T>
decltype(auto) get(const element_holder<I, T> &h) {
  return h.value;
}

template <size_t I, typename T> decltype(auto) get(element_holder<I, T> &h) {
  return h.value;
}
```
测试代码:
```c++
void test() {
  tuple<int, double> tp(1, 2.5);
  double t = get<1>(tp);
  assert(t == 2.5);

static_assert(std::is_trivially_copyable_v<tuple<int, double>>);
}
```
测试表明tuple```<int, double>```是trivially_copyable的。

还可以再加一些辅助方法：
```c++
template <typename T> struct tuple_size;

template <typename... Ts>
struct tuple_size<tuple<Ts...>>
    : public std::integral_constant<int, sizeof...(Ts)> {};

template <typename T>
inline constexpr auto tuple_size_v = tuple_size<std::decay_t<T>>::value;

template <class F, class Tuple, size_t... Is>
inline constexpr decltype(auto) apply_impl(F &&f, Tuple &&tp,
                                           std::index_sequence<Is...>) {
  return std::invoke(std::forward<F>(f), get<Is>(std::forward<Tuple>(tp))...);
}

template <class F, class Tuple>
inline constexpr decltype(auto) apply(F &&f, Tuple &&tp) {
  return apply_impl(
      std::forward<F>(f), std::forward<Tuple>(tp),
      std::make_index_sequence<tuple_size_v<std::remove_reference_t<Tuple>>>{});
}
```
测试代码：
```c++
void test() {
  tuple<int, int> tp(42, 1);
  static_assert(std::is_trivially_copyable_v<decltype(tp)>);
  static_assert(tuple_size_v<decltype(tp)> == 2);
  auto ret = apply([](int a, int b) {return a + b; }, tp);
  assert(ret == 43);
}
```

来说两句吧

最新评论

fqbqrr 2022-08-28 02:27:13

请问有不有提案,将`apply_impl`的这两段代码合二为一.因为它,太烦了,每次都要多写一个函数.

purecpp

一个很酷的modern c++开源社区

[社区开源项目列表，点击前往]

purecpp社区自2015年创办以来，以“Newer is Better”为理念，相信新技术可以改变世界，一直致力于现代C++研究、应用和技术创新，期望通过现代C++的技术创新来提高企业生产力和效率。

社区坚持只发表原创技术文章，已经累计发表了一千多篇原创C++技术文章；

组织了十几场的C++沙龙和C++大会，有力地促进了国内外C++开发者之间的技术交流；

开源了十几个现代C++项目，被近百家公司所使用，有力地推动了现代C++在企业中的应用。

期待更多的C++爱好者能参与到社区C++社区的建设中来，一起为现代C++开源项目添砖加瓦，一起完善C++基础设施和生态圈。

微信公众号:purecpp, 社区邮箱: purecpp@163.com

分类导航

社区精华社区开源项目社区活动元编程代码精粹技术探讨 C++11/14/17/20 社区故事

友情链接