From Jason Turner

[tuple.syn]

C++17 → C++20 3.6 KB 38 lines
Current Draft | LaTeX Source
Archived: C++17 | C++20
Markdown: C++17 | C++20
Explore in Adventure Game

Diff to HTML by rtfpessoa

Files changed (1) hide show
  1. tmp/tmpy0_06l56/{from.md → to.md} +12 -21
tmp/tmpy0_06l56/{from.md → to.md} RENAMED
@@ -1,18 +1,20 @@
1
  ### Header `<tuple>` synopsis <a id="tuple.syn">[[tuple.syn]]</a>
2
 
3
  ``` cpp
 
 
4
  namespace std {
5
  // [tuple.tuple], class template tuple
6
  template<class... Types>
7
  class tuple;
8
 
9
  // [tuple.creation], tuple creation functions
10
  inline constexpr unspecified ignore;
11
 
12
  template<class... TTypes>
13
- constexpr tuple<VTypes...> make_tuple(TTypes&&...);
14
 
15
  template<class... TTypes>
16
  constexpr tuple<TTypes&&...> forward_as_tuple(TTypes&&...) noexcept;
17
 
18
  template<class... TTypes>
@@ -27,24 +29,20 @@ namespace std {
27
 
28
  template<class T, class Tuple>
29
  constexpr T make_from_tuple(Tuple&& t);
30
 
31
  // [tuple.helper], tuple helper classes
32
- template <class T> class tuple_size; // not defined
33
- template <class T> class tuple_size<const T>;
34
- template <class T> class tuple_size<volatile T>;
35
- template <class T> class tuple_size<const volatile T>;
36
 
37
- template <class... Types> class tuple_size<tuple<Types...>>;
38
 
39
- template <size_t I, class T> class tuple_element; // not defined
40
- template <size_t I, class T> class tuple_element<I, const T>;
41
- template <size_t I, class T> class tuple_element<I, volatile T>;
42
- template <size_t I, class T> class tuple_element<I, const volatile T>;
43
 
44
  template<size_t I, class... Types>
45
- class tuple_element<I, tuple<Types...>>;
46
 
47
  template<size_t I, class T>
48
  using tuple_element_t = typename tuple_element<I, T>::type;
49
 
50
  // [tuple.elem], element access
@@ -67,27 +65,20 @@ namespace std {
67
 
68
  // [tuple.rel], relational operators
69
  template<class... TTypes, class... UTypes>
70
  constexpr bool operator==(const tuple<TTypes...>&, const tuple<UTypes...>&);
71
  template<class... TTypes, class... UTypes>
72
- constexpr bool operator<(const tuple<TTypes...>&, const tuple<UTypes...>&);
73
- template<class... TTypes, class... UTypes>
74
- constexpr bool operator!=(const tuple<TTypes...>&, const tuple<UTypes...>&);
75
- template<class... TTypes, class... UTypes>
76
- constexpr bool operator>(const tuple<TTypes...>&, const tuple<UTypes...>&);
77
- template<class... TTypes, class... UTypes>
78
- constexpr bool operator<=(const tuple<TTypes...>&, const tuple<UTypes...>&);
79
- template<class... TTypes, class... UTypes>
80
- constexpr bool operator>=(const tuple<TTypes...>&, const tuple<UTypes...>&);
81
 
82
  // [tuple.traits], allocator-related traits
83
  template<class... Types, class Alloc>
84
  struct uses_allocator<tuple<Types...>, Alloc>;
85
 
86
  // [tuple.special], specialized algorithms
87
  template<class... Types>
88
- void swap(tuple<Types...>& x, tuple<Types...>& y) noexcept(see below);
89
 
90
  // [tuple.helper], tuple helper classes
91
  template<class T>
92
  inline constexpr size_t tuple_size_v = tuple_size<T>::value;
93
  }
 
1
  ### Header `<tuple>` synopsis <a id="tuple.syn">[[tuple.syn]]</a>
2
 
3
  ``` cpp
4
+ #include <compare> // see [compare.syn]
5
+
6
  namespace std {
7
  // [tuple.tuple], class template tuple
8
  template<class... Types>
9
  class tuple;
10
 
11
  // [tuple.creation], tuple creation functions
12
  inline constexpr unspecified ignore;
13
 
14
  template<class... TTypes>
15
+ constexpr tuple<unwrap_ref_decay_t<TTypes>...> make_tuple(TTypes&&...);
16
 
17
  template<class... TTypes>
18
  constexpr tuple<TTypes&&...> forward_as_tuple(TTypes&&...) noexcept;
19
 
20
  template<class... TTypes>
 
29
 
30
  template<class T, class Tuple>
31
  constexpr T make_from_tuple(Tuple&& t);
32
 
33
  // [tuple.helper], tuple helper classes
34
+ template<class T> struct tuple_size; // not defined
35
+ template<class T> struct tuple_size<const T>;
 
 
36
 
37
+ template<class... Types> struct tuple_size<tuple<Types...>>;
38
 
39
+ template<size_t I, class T> struct tuple_element; // not defined
40
+ template<size_t I, class T> struct tuple_element<I, const T>;
 
 
41
 
42
  template<size_t I, class... Types>
43
+ struct tuple_element<I, tuple<Types...>>;
44
 
45
  template<size_t I, class T>
46
  using tuple_element_t = typename tuple_element<I, T>::type;
47
 
48
  // [tuple.elem], element access
 
65
 
66
  // [tuple.rel], relational operators
67
  template<class... TTypes, class... UTypes>
68
  constexpr bool operator==(const tuple<TTypes...>&, const tuple<UTypes...>&);
69
  template<class... TTypes, class... UTypes>
70
+ constexpr common_comparison_category_t<synth-three-way-result<TTypes, UTypes>...>
71
+ operator<=>(const tuple<TTypes...>&, const tuple<UTypes...>&);
 
 
 
 
 
 
 
72
 
73
  // [tuple.traits], allocator-related traits
74
  template<class... Types, class Alloc>
75
  struct uses_allocator<tuple<Types...>, Alloc>;
76
 
77
  // [tuple.special], specialized algorithms
78
  template<class... Types>
79
+ constexpr void swap(tuple<Types...>& x, tuple<Types...>& y) noexcept(see below);
80
 
81
  // [tuple.helper], tuple helper classes
82
  template<class T>
83
  inline constexpr size_t tuple_size_v = tuple_size<T>::value;
84
  }