tuple Class
The latest version of this topic can be found at tuple Class.
Wraps a fixed-length sequence of elements.
Syntax
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.
Remarks
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.
Example
// 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 ).
*\
Requirements
Header: <tuple>
Namespace: std
tuple::operator=
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
tuple:swap
Exchanges the elements of two tuples.
template <class... Types>
void swap(tuple<Types...&>
left,
tuple<Types...&> right);
Parameters
| Parameter | Description |
|---|---|
left |
A tuple whose elements are to be exchanged with those of the tuple right. |
right |
A tuple whose elements are to be exchanged with those of the tuple left. |
Remarks
The function executes left.swap(right).
tuple::tuple
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