C++可平凡复制的元组

原文
标::元组,无法优化性能.可平凡复制可使memcpy复制对象进二进制缓冲.

元<整 I,型名 T>构 元素持有者{
    用 类型=T;T 值;
};

元<型名 S,型名...T>构 元组实现;

元<型名...T,整...I>
构 元组实现<引序<I...>,T...>
    :元素持有者<I,T>...{
  元组实现()=默认;
  元组实现(T&&...t):元素持有者<I,T>{前向<T>(t)}...{}
};

元<型名...T>
构 元组:元组实现<造引序<的大小...(T)>,T...>{
  用 基=元组实现<造引序<的大小...(T)>,T...>;
  用 基::基;
};

元<整 I,型名 T>
推导(动)取(常 元素持有者<I,T>&h){ 中 h.值; }

元<整 I,型名 T>推导(动)取(元素持有者<I,T>&h){ 中 h.值; }
//测试代码:

空 测试(){
  元组<整,双精>tp(1,2.5);
  双精 t=取<1>(tp);
  断定(t==2.5);

  静断(是可平凡复制值<元组<整,双精>>);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

测试表明元组<整,双精>是可平凡复制的.还可以再加一些辅助方法:

元<型名 T>构 元组大小;

元<型名...T>构 元组大小<元组<T...>>
    :公 整常<整,的大小...(T)>{};

元<型名 T>
内联 常式 动 元组大小值=元组大小<退化型<T>>::值;

元<类 F,类 元组,整...I>
内联 常式 推导(动)应用实现(F&&f,元组&&tp,引序<I...>){
  中 调用(前向<F>(f),取<I>(前向<元组>(tp))...);
}

元<类 F,类 元组>
内联 常式 推导(动)应用(F&&f,元组&&tp){
  中 应用实现(
      前向<F>(f),前向<元组>(tp),
      造引序<元组大小值<移除引用型<元组>>>{});
}
//测试代码:

空 测试(){
  元组<整,整>tp(42,1);
  静断(是可平凡复制值<推导(tp)>);
  静断(元组大小值<推导(tp)>==2);
  动 中=应用([](整 a,整 b){中 a+b;},tp);
  断定(中==43);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28