std::tuple::tuple

From Cppreference

Jump to: navigation, search

Defined in header `<tuple>`

constexpr tuple();	(1)	(C++11 feature)

explicit tuple( const Types&... args );	(2)	(C++11 feature)

template< class... UTypes > explicit tuple( UTypes&&... args );	(3)	(C++11 feature)

template< class... UTypes > tuple( const tuple<UTypes...>& other );	(4)	(C++11 feature)

template <class... UTypes> tuple( tuple<UTypes...>&& other );	(5)	(C++11 feature)

template< class U1, class U2 > tuple( const pair<U1,U2>& p );	(6)	(C++11 feature)

template< class U1, class U2 > tuple( pair<U1,U2>&& p );	(7)	(C++11 feature)

tuple(const tuple& other) = default;	(8)	(C++11 feature)

tuple( tuple&& other ) = default;	(9)	(C++11 feature)

template< class Alloc > tuple( std::allocator_arg_t, const Alloc& a );	(10)	(C++11 feature)

template< class Alloc > tuple( std::allocator_arg_t, const Alloc& a, const Types&... args );	(11)	(C++11 feature)

template< class Alloc, class... UTypes > tuple( std::allocator_arg_t, const Alloc& a, const UTypes&&... args );	(12)	(C++11 feature)

template <class Alloc, class... UTypes> tuple( std::allocator_arg_t, const Alloc& a, const tuple<UTypes...>& other );	(13)	(C++11 feature)

template< class Alloc, class... UTypes > tuple( std::allocator_arg_t, const Alloc& a, tuple<UTypes...>&& other );	(14)	(C++11 feature)

template< class Alloc, class U1, class U2 > tuple( std::allocator_arg_t, const Alloc& a, const pair<U1, U2>& p );	(15)	(C++11 feature)

template< class Alloc, class U1, class U2 > tuple( std::allocator_arg_t, const Alloc& a, pair<U1, U2>&& p );	(16)	(C++11 feature)

template< class Alloc > tuple( std::allocator_arg_t, const Alloc& a, const tuple& other );	(17)	(C++11 feature)

template< class Alloc > tuple( std::allocator_arg_t, const Alloc& a, tuple&& other );	(18)	(C++11 feature)

Constructs a new tuple.

1) Default constructor. Value-initializes all elements.

2) Initializes each element of the tuple with the corresponding parameter.

3) Initializes each element of the tuple with the corresponding value in std::forward<Utypes>(args).

4) For all i in sizeof...(UTypes), initializes ith element of the tuple with std::get<i>(other).

5) For all i in sizeof...(UTypes), initializes ith element of the tuple with std::forward<Ui>(std::get<i>(other)).

6) Constructs a 2-element tuple with the first element constructed from p.first and the second element from p.second

7) Constructs a 2-element tuple with the first element constructed from std::forward<U1>(p.first) and the second element from std::forward<U2>(p.second)

8) Compiler-generated copy constructor. Initializes each element of the tuple with the corresponding element of other

9) Compiler-generated move constructor. Initializes each ith element of the tuple with std::forward<Ui>(std::get<i>(other)).

10 - 18) Identical to 1-9 except each element is created by uses-allocator construction, that is, the Allocator object a is passed as an additional argument to the constructor of each element for which std::uses_allocator<Ui, Alloc>::value is true.

[edit] Parameters

`args`	-	values used to initialize each element of the tuple
`other`	-	a tuple of values used to initialize each element of the tupe
`p`	-	pair of values used to initialize both elements of this 2-tuple
`a`	-	allocator to use in uses-allocator construction

[edit] Example

#include <iostream>
#include <string>
#include <vector>
#include <tuple>
#include <memory>
 
// helper function to print a tuple of any size
template<class Tuple, std::size_t N>
struct TuplePrinter {
    static void print(const Tuple& t) 
    {
        TuplePrinter<Tuple, N-1>::print(t);
        std::cout << ", " << std::get<N-1>(t);
    }
};
 
template<class Tuple>
struct TuplePrinter<Tuple, 1>{
    static void print(const Tuple& t) 
    {
        std::cout << std::get<0>(t);
    }
};
 
template<class... Args>
void print(const std::tuple<Args...>& t) 
{
    std::cout << "(";
    TuplePrinter<decltype(t), sizeof...(Args)>::print(t);
    std::cout << ")\n";
}
// end helper function
 
int main()
{
    std::tuple<int, std::string, double> t1;
    std::cout << "Value-initialized: "; print(t1);
    std::tuple<int, std::string, double> t2(42, "Test", -3.14);
    std::cout << "Initialized with values: "; print(t2);
    std::tuple<char, std::string, int> t3(t2);
    std::cout << "Implicitly converted: "; print(t3);
    std::tuple<int, double> t4(std::make_pair(42, 3.14));
    std::cout << "Constructed from a pair"; print(t4);
 
    // given Allocator my_alloc with a single-argument constructor my_alloc(int)
    // use my_alloc(1) to allocate 10 ints in a vector
    std::vector<int, my_alloc> v(10, 1, my_alloc(1));
    // use my_alloc(2) to allocate 10 ints in a vector in a tuple
    std::tuple<int, std::vector<int, my_alloc>, double> t5(std::allocator_arg,
                                                           my_alloc(2), 42, v,  -3.14);
}

Output:

Value-initialized: (0, , 0)
Initialized with values: (42, Test, -3.14)
Implicitly converted: (*, Test, -3)
Constructed from a pair(42, 3.14)

[edit] See also

make_tuple

creates a tuple object of the type defined by the argument types
(function template)

tie

creates a tuple of lvalue references or unpacks a tuple into individual objects
(function template)

forward_as_tuple

creates a tuple of rvalue references
(function template)