tuple (Clase)

 

Para obtener la documentación más reciente de Visual Studio 2017 RC, consulte Documentación de Visual Studio 2017 RC.

Ajusta una secuencia de longitud fija de elementos.

{de tupla de clase
público:
Tuple(); tupla explícita (P1, P2,..., PN); 0
Tuple(const Tuple&); plantilla<class u1,="" class="" u2,="" ...,="" class="" un="">
tupla (const tupla<U1, u2,="" ...,="" un="">&); plantilla <class u1,="" class="" u2=""> </U1,>
tupla (const par<U1, u2="">&); / / N == 2</U1,>
void swap (tupla aspecto derecha); tupla aspecto operador =(const tuple&); plantilla<class u1,="" class="" u2,="" ...,="" class="" un="">
tupla aspecto operador = (const tupla<U1, u2,="" ...,="" un="">&); plantilla <class u1,="" class="" u2=""> </U1,>
tupla aspecto operador = (const par<U1, u2="">&); / / N == 2</U1,>
};

Parámetros

TN
Tipo del enésimo elemento de la tupla.

La clase de plantilla describe un objeto que almacena objetos N de tipos T1, T2,..., TN, respectivamente, donde donde 0 <= N <= Nmax. El alcance de una instancia de la tupla tuple<T1, T2, ..., TN> es el número N de sus argumentos de plantilla. El índice del argumento de plantilla Ti y del valor almacenado correspondiente de ese tipo es i - 1. Por lo tanto, mientras que el número de los tipos de 1 a N en esta documentación, el índice correspondiente valores comprendidos entre 0 y 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 ).  
*\  

Encabezado:<>>

Espacio de nombres: std

Asigna un tuple objeto.

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

Parámetros

UN
Tipo del enésimo elemento copiado de la tupla.

right
Tupla de la que se va a copiar.

Comentarios

Los primeros operadores de dos miembros asignar los elementos de right a los elementos correspondientes de *this. El tercer operador de miembro asigna right.first al elemento en el índice 0 de *this y right.second al elemento en el índice 1. Devuelven todos los operadores de tres miembros *this.

Los operadores de miembros restantes son análogos a los anteriores, pero con declarador de referencia Rvalue: &&.

Ejemplo

// 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  

Intercambia los elementos de dos tuplas.

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

Parámetros

ParámetroDescripción
leftUna tupla cuyos elementos son van a intercambiar con los de la tupla right.
rightUna tupla cuyos elementos son van a intercambiar con los de la tupla left.

Comentarios

Ejecuta la función left.swap(right).

Construye un objeto tuple.

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  

Parámetros

UN
Tipo del enésimo elemento copiado de la tupla.

right
Tupla de la que se va a copiar.

Comentarios

El primer constructor crea un objeto cuyos elementos se han construido de forma predeterminada.

El segundo constructor crea un objeto cuyos elementos se han creado a partir de los argumentos P1, P2, ..., PN con cada Pi inicializando el elemento en el índice i - 1.

El tercer y cuarto constructores crean un objeto cuyos elementos se han copiado a partir del elemento correspondiente de right.

El quinto constructor crea un objeto cuyo elemento en el índice 0 se ha copiado a partir de right.first y cuyo elemento en el índice 1 se ha copiado a partir de right.second.

Los constructores restantes son análogos a los anteriores, pero con declarador de referencia Rvalue: &&.

Ejemplo

// 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  

<>>
make_tuple (función)

Mostrar: