tuple Class

 

Wraps a fixed-length sequence of elements.

class tuple {
public:
tuple(); explicit tuple(P1, P2, ..., PN); // 0 <N
tuple(const tuple&); template <class U1, class U2, ..., class UN>
tuple(const tuple<U1, U2, ..., UN>&); template <class U1, class U2>
tuple(const pair<U1, U2>&); // N == 2
void swap(tuple& right); tuple& operator=(const tuple&); template <class U1, class U2, ..., class UN>
tuple& operator=(const tuple<U1, U2, ..., UN>&); template <class U1, class U2>
tuple& operator=(const pair<U1, U2>&); // N == 2
};

Parameters

TN
The type of the Nth tuple element.

The template class describes an object that stores N objects of types T1, T2, ..., TN, respectively, where where 0 <= N <= Nmax. The extent of a tuple instance tuple<T1, T2, ..., TN> is the number N of its template arguments. The index of the template argument Ti and of the corresponding stored value of that type is i - 1. Thus, while we number the types from 1 to N in this documentation, the corresponding index values range from 0 to N - 1.

// tuple.cpp  
// compile with: /EHsc  
  
#include <vector>  
#include <iomanip>  
#include <iostream>  
#include <tuple>  
#include <string>  
  
using namespace std;  
  
typedef tuple <int, double, string> ids;  
  
void print_ids(const ids& i)  
{  
   cout << "( "  
        << get<0>(i) << ", "   
        << get<1>(i) << ", "   
        << get<2>(i) << " )." << endl;  
}  
  
int main( )  
{  
   // Using the constructor to declare and initialize a tuple  
   ids p1(10, 1.1e-2, "one");  
  
   // Compare using the helper function to declare and initialize a tuple  
   ids p2;  
   p2 = make_tuple(10, 2.22e-1, "two");  
  
   // Making a copy of a tuple  
   ids p3(p1);  
  
   cout.precision(3);  
   cout << "The tuple p1 is: ( ";  
   print_ids(p1);  
   cout << "The tuple p2 is: ( ";  
   print_ids(p2);  
   cout << "The tuple p3 is: ( ";  
   print_ids(p3);  
  
   vector<ids> v;  
  
   v.push_back(p1);  
   v.push_back(p2);  
   v.push_back(make_tuple(3, 3.3e-2, "three"));  
  
   cout << "The tuples in the vector are" << endl;  
   for(vector<ids>::const_iterator i = v.begin(); i != v.end(); ++i)  
   {  
      print_ids(*i);  
   }  
}  
\* Output:   
The tuple p1 is: ( 10, 0.011, one ).  
The tuple p2 is: ( 10, 0.222, two ).  
The tuple p3 is: ( 10, 0.011, one ).  
The tuples in the vector are  
( 10, 0.011, one ).  
( 10, 0.222, two ).  
( 3, 0.033, three ).  
*\  

Header: <tuple>

Namespace: std

Assigns a tuple object.

tuple& operator=(const tuple& right);

template <class U1, class U2, ..., class UN>  
tuple& operator=(const tuple<U1, U2, ..., UN>& right);

template <class U1, class U2>  
tuple& operator=(const pair<U1, U2>& right);
// N == 2  
tuple& operator=(tuple&& right);

template <class U1, class U2>  
tuple& operator=(pair<U1, U2>&& right);

Parameters

UN
The type of the Nth copied tuple element.

right
The tuple to copy from.

Remarks

The first two member operators assign the elements of right to the corresponding elements of *this. The third member operator assigns right.first to the element at index 0 of *this and right.second to the element at index 1. All three member operators return *this.

The remaining member operators are analogs to earlier ones, but with Rvalue Reference Declarator: &&.

Example

// std_tr1__tuple__tuple_operator_as.cpp   
// compile with: /EHsc   
#include <tuple>   
#include <iostream>   
#include <utility>   
  
typedef std::tuple<int, double, int, double> Mytuple;   
int main()   
    {   
    Mytuple c0(0, 1, 2, 3);   
  
// display contents " 0 1 2 3"   
    std::cout << " " << std::get<0>(c0);   
    std::cout << " " << std::get<1>(c0);   
    std::cout << " " << std::get<2>(c0);   
    std::cout << " " << std::get<3>(c0);   
    std::cout << std::endl;   
  
    Mytuple c1;   
    c1 = c0;   
  
// display contents " 0 1 2 3"   
    std::cout << " " << std::get<0>(c1);   
    std::cout << " " << std::get<1>(c1);   
    std::cout << " " << std::get<2>(c1);   
    std::cout << " " << std::get<3>(c1);   
    std::cout << std::endl;   
  
    std::tuple<char, int> c2;   
    c2 = std::make_pair('x', 4);   
  
// display contents " x 4"   
    std::cout << " " << std::get<0>(c2);   
    std::cout << " " << std::get<1>(c2);   
    std::cout << std::endl;   
  
    return (0);   
    }  
  

0 1 2 3  
0 1 2 3  
x 4  

Exchanges the elements of two tuples.

template <class... Types>  
void swap(tuple<Types...&>  
left,  
    tuple<Types...&> right);

Parameters

ParameterDescription
leftA tuple whose elements are to be exchanged with those of the tuple right.
rightA tuple whose elements are to be exchanged with those of the tuple left.

Remarks

The function executes left.swap(right).

Constructs a tuple object.

constexpr tuple();

 
    explicit constexpr tuple(const Types&...);

 
    template <class... UTypes>   
explicit constexpr tuple(UTypes&&...);

 
tuple(const tuple&) = default;  
    tuple(tuple&&) = default;  
 
template <class... UTypes>  
constexpr tuple(const tuple<UTypes...>&);

 
    template <class... UTypes>  
constexpr tuple(tuple<UTypes...>&&);

 
template <class U1, class U2>   
constexpr tuple(const pair<U1, U2>&);

// only if sizeof...(Types) == 2   
 
template <class U1, class U2>  
constexpr tuple(pair<U1, U2>&&);

// only if sizeof...(Types) == 2  

Parameters

UN
The type of the Nth copied tuple element.

right
The tuple to copy from.

Remarks

The first constructor constructs an object whose elements are default constructed.

The second constructor constructs an object whose elements are copy constructed from the arguments P1, P2, ..., PN with each Pi initializing the element at index i - 1.

The third and fourth constructors construct an object whose elements are copy constructed from the corresponding element of right.

The fifth constructor constructs an object whose element at index 0 is copy constructed from right.first and whose element at index 1 is copy constructed from right.second.

The remaining constructors are analogs to earlier ones, but with Rvalue Reference Declarator: &&.

Example

// std_tr1__tuple__tuple_tuple.cpp   
// compile with: /EHsc   
#include <tuple>   
#include <iostream>   
#include <utility>   
  
typedef std::tuple<int, double, int, double> Mytuple;   
int main()   
    {   
    Mytuple c0(0, 1, 2, 3);   
  
// display contents " 0 1 2 3"   
    std::cout << " " << std::get<0>(c0);   
    std::cout << " " << std::get<1>(c0);   
    std::cout << " " << std::get<2>(c0);   
    std::cout << " " << std::get<3>(c0);   
    std::cout << std::endl;   
  
    Mytuple c1;   
    c1 = c0;   
  
// display contents " 0 1 2 3"   
    std::cout << " " << std::get<0>(c1);   
    std::cout << " " << std::get<1>(c1);   
    std::cout << " " << std::get<2>(c1);   
    std::cout << " " << std::get<3>(c1);   
    std::cout << std::endl;   
  
    std::tuple<char, int> c2(std::make_pair('x', 4));   
  
// display contents " x 4"   
    std::cout << " " << std::get<0>(c2);   
    std::cout << " " << std::get<1>(c2);   
    std::cout << std::endl;   
  
    Mytuple c3(c0);   
  
// display contents " 0 1 2 3"   
    std::cout << " " << std::get<0>(c3);   
    std::cout << " " << std::get<1>(c3);   
    std::cout << " " << std::get<2>(c3);   
    std::cout << " " << std::get<3>(c3);   
    std::cout << std::endl;   
  
    typedef std::tuple<int, float, int, float> Mytuple2;   
    Mytuple c4(Mytuple2(4, 5, 6, 7));   
  
// display contents " 4 5 6 7"   
    std::cout << " " << std::get<0>(c4);   
    std::cout << " " << std::get<1>(c4);   
    std::cout << " " << std::get<2>(c4);   
    std::cout << " " << std::get<3>(c4);   
    std::cout << std::endl;   
  
    return (0);   
    }  
  

0 1 2 3  
0 1 2 3  
x 4  
0 1 2 3  
4 5 6 7  

<tuple>
make_tuple Function

Show: