Showing content from https://cplusplus.com/reference/tuple/tuple/tuple/ below:
public member function
<tuple>
std::tuple::tuple default (1)
constexpr tuple();
copy / move (2)
tuple (const tuple& tpl) = default;tuple (tuple&& tpl) = default;
implicit conversion (3)
template <class... UTypes> tuple (const tuple<UTypes...>& tpl);template <class... UTypes> tuple (tuple<UTypes...>&& tpl);
initialization (4)
explicit tuple (const Types&... elems);template <class... UTypes> explicit tuple (UTypes&&... elems);
conversion from pair (5)
template <class U1, class U2> tuple (const pair<U1,U2>& pr);template <class U1, class U2> tuple (pair<U1,U2>&& pr);
allocator (6)
template<class Alloc> tuple (allocator_arg_t aa, const Alloc& alloc);template<class Alloc> tuple (allocator_arg_t aa, const Alloc& alloc, const tuple& tpl);template<class Alloc> tuple (allocator_arg_t aa, const Alloc& alloc, tuple&& tpl);template<class Alloc,class... UTypes> tuple (allocator_arg_t aa, const Alloc& alloc, const tuple<UTypes...>& tpl);template<class Alloc, class... UTypes> tuple (allocator_arg_t aa, const Alloc& alloc, tuple<UTypes...>&& tpl);template<class Alloc> tuple (allocator_arg_t aa, const Alloc& alloc, const Types&... elems);template<class Alloc, class... UTypes> tuple (allocator_arg_t aa, const Alloc& alloc, UTypes&&... elems);template<class Alloc, class U1, class U2> tuple (allocator_arg_t aa, const Alloc& alloc, const pair<U1,U2>& pr);template<class Alloc, class U1, class U2> tuple (allocator_arg_t aa, const Alloc& alloc, pair<U1,U2>&& pr);
Construct tuple
Constructs a tuple object.
This involves individually constructing its elements, with an initialization that depends on the constructor form invoked:
-
(1) default constructor
-
Constructs a tuple object with its elements value-initialized.
-
(2) copy / move constructor
-
The object is initialized with the contents of the tpl tuple object.
The corresponding element of tpl is passed to the constructor of each element.
-
(3) implicit conversion constructor
-
Same as above.
All types in tpl shall be implicitly convertible to the type of their respective element in the constructed tuple object.
-
(4) initialization constructor
-
Initializes each element with the corresponding element in elems.
The corresponding element of elems is passed to the constructor of each element.
-
(5) pair conversion constructor
-
The object has two elements corresponding to
pr.first and pr.second. All types in pr shall be implicitly convertible to the type of their respective element in the tuple object.
-
(6) allocator versions
-
Same as the versions above, except that each element is constructed using allocator alloc.
Most forms have two signatures: one taking const lvalue references, which copies the elements into the tuple, and one taking rvalue references, which moves them instead if their types support move semantics (i.e., the contents are transferred to the tuple object and lost by their previous referrers, which are left in an unspecified but valid state).
Parameters
-
tpl
-
Another tuple object with the same number of elements.
This may be an object of the same type as the object being constructed (version 2) or of a tuple type whose elements' types are implicitly convertible to those in the tuple object being constructed.
-
elems...
-
A series of elements, each of their corresponding type in Types or UTypes template parameters.
-
pr
-
A pair object whose first and second types (U1 and U2) match those used as class template arguments, or are implicitly convertible to them.
-
aa
-
The std::allocator_arg value. This constant value is merely used to select the constructor forms with an allocator parameter.
-
alloc
-
Allocator object used to construct the elements.
Example
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
// tuple constructors
#include <iostream> // std::cout
#include <utility> // std::make_pair
#include <tuple> // std::tuple, std::make_tuple, std::get
int main ()
{
std::tuple<int,char> first; // default
std::tuple<int,char> second (first); // copy
std::tuple<int,char> third (std::make_tuple(20,'b')); // move
std::tuple<long,char> fourth (third); // implicit conversion
std::tuple<int,char> fifth (10,'a'); // initialization
std::tuple<int,char> sixth (std::make_pair(30,'c')); // from pair / move
std::cout << "sixth contains: " << std::get<0>(sixth);
std::cout << " and " << std::get<1>(sixth) << '\n';
return 0;
}
Output:
Data races The elements of tpl and pr are accessed.
The constructors taking rvalue references as arguments modify these arguments if their types support move semantics for this construction.
Exception safety If none of the individual constructions of elements of tuple can throw, the operation never throws exceptions (no-throw guarantee).
Otherwise, if any of the signatures taking an rvalue reference as argument is called, and at least one of the types in the tuple can be constructed with move semantics, the operation may leave tpl (or pr) in an invalid state in case of exception (no guarantees).
Otherwise, the function only implies copies and the operation produces no side effects (strong guarantee).
See also
-
tuple::operator=
-
Assign content (public member function)
-
make_tuple
-
Construct tuple (function template)
-
pair
-
Pair of values (class template)
RetroSearch is an open source project built by @garambo
| Open a GitHub Issue
Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo
HTML:
3.2
| Encoding:
UTF-8
| Version:
0.7.4