Espacios de nombres
Variantes
Acciones

std::tuple::tuple

De cppreference.com
< cpp‎ | utility‎ | tuple

 
 
Utilidades de la biblioteca
Escriba apoyo (basic types, RTTI, type traits)
Gestión de memoria dinámica
Gestión de errores
Programa de servicios públicos
Funciones variadic
Fecha y hora
Objetos Function
initializer_list(C++11)
bitset
hash(C++11)
Operadores relacionales
Original:
Relational operators
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
rel_ops::operator!=
rel_ops::operator>
rel_ops::operator<=
rel_ops::operator>=
Pares y tuplas
Original:
Pairs and tuples
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
pair
tuple(C++11)
piecewise_construct_t(C++11)
piecewise_construct(C++11)
Cambiar, hacia adelante y mover
Original:
Swap, forward and move
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
swap
forward(C++11)
move(C++11)
move_if_noexcept(C++11)
declval(C++11)
 
std::tuple
Las funciones miembro
Original:
Member functions
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
tuple::tuple
tuple::operator=
tuple::swap
Terceros funciones
Original:
Non-member functions
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
make_tuple
tie
forward_as_tuple
None
operator=
operator!=
operator<
operator<=
operator>
operator>=
std::swap
get
Clases de ayuda
Original:
Helper classes
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
tuple_size
tuple_element
uses_allocator
ignore
 
Defined in header <tuple>
constexpr tuple();
(1) (desde C++11)
explicit tuple( const Types&... args );
(2) (desde C++11)
template< class... UTypes >
explicit tuple( UTypes&&... args );
(3) (desde C++11)
template< class... UTypes >
tuple( const tuple<UTypes...>& other );
(4) (desde C++11)
template <class... UTypes>
tuple( tuple<UTypes...>&& other );
(5) (desde C++11)
template< class U1, class U2 >
tuple( const pair<U1,U2>& p );
(6) (desde C++11)
template< class U1, class U2 >
tuple( pair<U1,U2>&& p );
(7) (desde C++11)
tuple( const tuple& other ) = default;
(8) (desde C++11)
tuple( tuple&& other ) = default;
(9) (desde C++11)
template< class Alloc >
tuple( std::allocator_arg_t, const Alloc& a );
(10) (desde C++11)
template< class Alloc >
tuple( std::allocator_arg_t, const Alloc& a, const Types&... args );
(11) (desde C++11)
template< class Alloc, class... UTypes >
tuple( std::allocator_arg_t, const Alloc& a, UTypes&&... args );
(12) (desde C++11)
template <class Alloc, class... UTypes>
tuple( std::allocator_arg_t, const Alloc& a, const tuple<UTypes...>& other );
(13) (desde C++11)
template< class Alloc, class... UTypes >
tuple( std::allocator_arg_t, const Alloc& a, tuple<UTypes...>&& other );
(14) (desde C++11)
template< class Alloc, class U1, class U2 >
tuple( std::allocator_arg_t, const Alloc& a, const pair<U1, U2>& p );
(15) (desde C++11)
template< class Alloc, class U1, class U2 >
tuple( std::allocator_arg_t, const Alloc& a, pair<U1, U2>&& p );
(16) (desde C++11)
template< class Alloc >
tuple( std::allocator_arg_t, const Alloc& a, const tuple& other );
(17) (desde C++11)
template< class Alloc >
tuple( std::allocator_arg_t, const Alloc& a, tuple&& other );
(18) (desde C++11)
Crea una nueva tupla .
Original:
Constructs a new tuple.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
1)
Por defecto constructor. Valor inicializa todos los elementos .
Original:
Default constructor. Value-initializes all elements.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
2)
Inicializa cada elemento de la tupla con el parámetro correspondiente .
Original:
Initializes each element of the tuple with the corresponding parameter.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
3)
Inicializa cada elemento de la tupla con el valor correspondiente en std::forward<Utypes>(args) .
Original:
Initializes each element of the tuple with the corresponding value in std::forward<Utypes>(args).
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
4)
Para todos i en sizeof...(UTypes), inicializa i-ésimo elemento de la tupla con std::get<i>(other) .
Original:
For all i in sizeof...(UTypes), initializes ith element of the tuple with std::get<i>(other).
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
5)
Para todos i en sizeof...(UTypes), inicializa i-ésimo elemento de la tupla con std::forward<Ui>(std::get<i>(other)) .
Original:
For all i in sizeof...(UTypes), initializes ith element of the tuple with std::forward<Ui>(std::get<i>(other)).
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
6)
Construye una tupla 2-elemento con el primer elemento construido a partir de p.first y el segundo elemento de p.second
Original:
Constructs a 2-element tuple with the first element constructed from p.first and the second element from p.second
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
7)
Construye una tupla 2-elemento con el primer elemento construido a partir de std::forward<U1>(p.first) y el segundo elemento de std::forward<U2>(p.second)
Original:
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)
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
8)
Generado por el compilador constructor de copia. Inicializa cada elemento de la tupla con el elemento correspondiente de other
Original:
Compiler-generated copy constructor. Initializes each element of the tuple with the corresponding element of other
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
9)
Generado por el compilador constructor movimiento. Inicializa cada i-ésimo elemento de la tupla con std::forward<Ui>(std::get<i>(other)) .
Original:
Compiler-generated move constructor. Initializes each ith element of the tuple with std::forward<Ui>(std::get<i>(other)).
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
10 a 18) Idéntica a 01.09, excepto que cada elemento es creado por' usos construcción-repartidor, es decir, se pasa el objeto a Becario como un argumento adicional para el constructor de cada elemento para el que std::uses_allocator<Ui, Alloc>::value es true .
Original:
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.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

[editar] Parámetros

args -
Los valores utilizados para inicializar cada elemento de la tupla
Original:
values used to initialize each element of the tuple
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
other -
una tupla de valores que se utilizan para inicializar cada elemento del tupe
Original:
a tuple of values used to initialize each element of the tupe
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
p -
par de valores que se utilizan para inicializar los dos elementos de este 2-tupla
Original:
pair of values used to initialize both elements of this 2-tuple
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
a -
asignador de utilizar en la construcción de usos-asignador
Original:
allocator to use in uses-allocator construction
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

[editar] Ejemplo

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

[editar] Ver también

crea un objeto tuple del tipo definido por los tipos de argumentos
Original:
creates a tuple object of the type defined by the argument types
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

(función de plantilla) [edit]
crea una tuple de referencias lvalue o desempaqueta una tupla en objetos individuales
Original:
creates a tuple of lvalue references or unpacks a tuple into individual objects
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

(función de plantilla) [edit]
crea un tuple de referencias rvalue
Original:
creates a tuple of rvalue references
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

(función de plantilla) [edit]