std::tuple::tuple

 

C++

Language

Standard library headers

Concepts

Utilities library

Strings library

Containers library

Algorithms library

Iterators library

Numerics library

Input/output library

Localizations library

Regular expressions library (C++11)

Atomic operations library (C++11)

Thread support library (C++11)

 

Utilities library

Type support (basic types, RTTI, type traits)

Dynamic memory management

Error handling

Program utilities

Variadic functions

Date and time

Function objects

initializer_list (C++11)

bitset

hash (C++11)

Relational operators

rel_ops::operator!=rel_ops::operator>rel_ops::operator<=rel_ops::operator>=

Pairs and tuples

pair

tuple (C++11)

piecewise_construct_t (C++11)

piecewise_construct (C++11)

Swap, forward and move

swap

forward (C++11)

move (C++11)

move_if_noexcept (C++11)

declval (C++11)

 

std::tuple

Member functions

tuple::tuple

tuple::operator=

tuple::swap

Non-member functions

make_tuple

tie

forward_as_tuple

tuple_cat

operator==operator!=operator<operator<=operator>operator>=

std::swap

get

Helper classes

tuple_size

tuple_element

uses_allocator

ignore

 

Defined in header <tuple>
constexpr tuple();	(1)	(since C++11)
explicit tuple( const Types&... args );	(2)	(since C++11) (until C++14)
explicit constexpr tuple( const Types&... args );	(2)	(since C++14)
template< class... UTypes > explicit tuple( UTypes&&... args );	(3)	(since C++11) (until C++14)
template< class... UTypes > explicit constexpr tuple( UTypes&&... args );	(3)	(since C++14)
template< class... UTypes > tuple( const tuple<UTypes...>& other );	(4)	(since C++11) (until C++14)
template< class... UTypes > constexpr tuple( const tuple<UTypes...>& other );	(4)	(since C++14)
template <class... UTypes> tuple( tuple<UTypes...>&& other );	(5)	(since C++11) (until C++14)
template <class... UTypes> constexpr tuple( tuple<UTypes...>&& other );	(5)	(since C++14)
template< class U1, class U2 > tuple( const pair<U1,U2>& p );	(6)	(since C++11) (until C++14)
template< class U1, class U2 > constexpr tuple( const pair<U1,U2>& p );	(6)	(since C++14)
template< class U1, class U2 > tuple( pair<U1,U2>&& p );	(7)	(since C++11) (until C++14)
template< class U1, class U2 > constexpr tuple( pair<U1,U2>&& p );	(7)	(since C++14)
tuple( const tuple& other ) = default;	(8)	(since C++11)
tuple( tuple&& other ) = default;	(9)	(since C++11)
template< class Alloc > tuple( std::allocator_arg_t, const Alloc& a );	(10)	(since C++11)
template< class Alloc > tuple( std::allocator_arg_t, const Alloc& a, const Types&... args );	(11)	(since C++11)
template< class Alloc, class... UTypes > tuple( std::allocator_arg_t, const Alloc& a, UTypes&&... args );	(12)	(since C++11)
template <class Alloc, class... UTypes> tuple( std::allocator_arg_t, const Alloc& a, const tuple<UTypes...>& other );	(13)	(since C++11)
template< class Alloc, class... UTypes > tuple( std::allocator_arg_t, const Alloc& a, tuple<UTypes...>&& other );	(14)	(since C++11)
template< class Alloc, class U1, class U2 > tuple( std::allocator_arg_t, const Alloc& a, const pair<U1, U2>& p );	(15)	(since C++11)
template< class Alloc, class U1, class U2 > tuple( std::allocator_arg_t, const Alloc& a, pair<U1, U2>&& p );	(16)	(since C++11)
template< class Alloc > tuple( std::allocator_arg_t, const Alloc& a, const tuple& other );	(17)	(since C++11)
template< class Alloc > tuple( std::allocator_arg_t, const Alloc& a, tuple&& other );	(18)	(since C++11)

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. This constructor is constexpr if every operation it performs is constexpr. For the empty tuple std::tuple<>, it is constexpr.

9) Compiler-generated move constructor. Initializes each ith element of the tuple with std::forward<Ui>(std::get<i>(other)). This constructor is constexpr if every operation it performs is constexpr. For the empty tuple std::tuple<>, it is constexpr.

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.

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

Example

Run this code

#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)

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)