From Jason Turner

[tuple.general]

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

Diff to HTML by rtfpessoa

Files changed (1) hide show
  1. tmp/tmp177yyrkd/{from.md → to.md} +0 -78
tmp/tmp177yyrkd/{from.md → to.md} RENAMED
@@ -6,83 +6,5 @@ arguments. Each template argument specifies the type of an element in
6
  the `tuple`. Consequently, tuples are heterogeneous, fixed-size
7
  collections of values. An instantiation of `tuple` with two arguments is
8
  similar to an instantiation of `pair` with the same two arguments. See 
9
  [[pairs]].
10
 
11
- ``` cpp
12
- namespace std {
13
- // [tuple.tuple], class template tuple:
14
- template <class... Types> class tuple;
15
-
16
- // [tuple.creation], tuple creation functions:
17
- const unspecified ignore;
18
-
19
- template <class... Types>
20
- constexpr tuple<VTypes...> make_tuple(Types&&...);
21
- template <class... Types>
22
- constexpr tuple<Types&&...> forward_as_tuple(Types&&...) noexcept;
23
-
24
- template<class... Types>
25
- constexpr tuple<Types&...> tie(Types&...) noexcept;
26
-
27
- template <class... Tuples>
28
- constexpr tuple<Ctypes...> tuple_cat(Tuples&&...);
29
-
30
- // [tuple.helper], tuple helper classes:
31
- template <class T> class tuple_size; // undefined
32
- template <class T> class tuple_size<const T>;
33
- template <class T> class tuple_size<volatile T>;
34
- template <class T> class tuple_size<const volatile T>;
35
-
36
- template <class... Types> class tuple_size<tuple<Types...> >;
37
-
38
- template <size_t I, class T> class tuple_element; // undefined
39
- template <size_t I, class T> class tuple_element<I, const T>;
40
- template <size_t I, class T> class tuple_element<I, volatile T>;
41
- template <size_t I, class T> class tuple_element<I, const volatile T>;
42
-
43
- template <size_t I, class... Types> class 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:
49
- template <size_t I, class... Types>
50
- constexpr tuple_element_t<I, tuple<Types...>>&
51
- get(tuple<Types...>&) noexcept;
52
- template <size_t I, class... Types>
53
- constexpr tuple_element_t<I, tuple<Types...>>&&
54
- get(tuple<Types...>&&) noexcept;
55
- template <size_t I, class... Types>
56
- constexpr const tuple_element_t<I, tuple<Types...>>&
57
- get(const tuple<Types...>&) noexcept;
58
- template <class T, class... Types>
59
- constexpr T& get(tuple<Types...>& t) noexcept;
60
- template <class T, class... Types>
61
- constexpr T&& get(tuple<Types...>&& t) noexcept;
62
- template <class T, class... Types>
63
- constexpr const T& get(const tuple<Types...>& t) noexcept;
64
-
65
- // [tuple.rel], relational operators:
66
- template<class... TTypes, class... UTypes>
67
- constexpr bool operator==(const tuple<TTypes...>&, const tuple<UTypes...>&);
68
- template<class... TTypes, class... UTypes>
69
- constexpr bool operator<(const tuple<TTypes...>&, const tuple<UTypes...>&);
70
- template<class... TTypes, class... UTypes>
71
- constexpr bool operator!=(const tuple<TTypes...>&, const tuple<UTypes...>&);
72
- template<class... TTypes, class... UTypes>
73
- constexpr bool operator>(const tuple<TTypes...>&, const tuple<UTypes...>&);
74
- template<class... TTypes, class... UTypes>
75
- constexpr bool operator<=(const tuple<TTypes...>&, const tuple<UTypes...>&);
76
- template<class... TTypes, class... UTypes>
77
- constexpr bool operator>=(const tuple<TTypes...>&, const tuple<UTypes...>&);
78
-
79
- // [tuple.traits], allocator-related traits
80
- template <class... Types, class Alloc>
81
- struct uses_allocator<tuple<Types...>, Alloc>;
82
-
83
- // [tuple.special], specialized algorithms:
84
- template <class... Types>
85
- void swap(tuple<Types...>& x, tuple<Types...>& y) noexcept(see below);
86
- }
87
- ```
88
-
 
6
  the `tuple`. Consequently, tuples are heterogeneous, fixed-size
7
  collections of values. An instantiation of `tuple` with two arguments is
8
  similar to an instantiation of `pair` with the same two arguments. See 
9
  [[pairs]].
10