std::forward_as_tuple

 

C++

Idioma

Conceptos

Utilidades de la biblioteca

Strings biblioteca

Contenedores biblioteca

Algoritmos biblioteca

Los iteradores biblioteca

Numéricos biblioteca

Entrada / salida de la biblioteca

Localizaciones biblioteca

Expresiones biblioteca Regular (C++11)

Operaciones de biblioteca Atómica (C++11)

Tema Biblioteca de ayuda (C++11)

 

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>
template< class... Types > tuple<Types...> forward_as_tuple( Types&&... args );		(ya que C + +11)

Construye una tupla de referencias a los argumentos en args adecuados para la transmisión como argumento a una función. La tupla tiene rvalue miembros de datos de referencia cuando rvalues ​​se utilizan como argumentos, y por lo demás tiene lvalue miembros de datos de referencia. Si rvalues ​​se utiliza, el resultado de esta función debe ser consumido antes de que el punto de secuencia siguiente .

Original:

Constructs a tuple of references to the arguments in args suitable for forwarding as an argument to a function. The tuple has rvalue reference data members when rvalues are used as arguments, and otherwise has lvalue reference data members. If rvalues are used, the result of this function must be consumed before the next sequence point.

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

Parámetros

args

-

cero o más argumentos para construir la tupla Original: zero or more arguments to construct the tuple from The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions.

Valor de retorno

Un objeto creado std::tuple como por std::tuple<Types&&...>(std::forward<Types>(args)...)

Original:

A std::tuple object created as if by std::tuple<Types&&...>(std::forward<Types>(args)...)

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

Excepciones

noexcept specification:  

noexcept

  (ya que C + +11)

Ejemplo

#include <iostream>
#include <map>
#include <tuple>
#include <string>
 
int main()
{
    std::map<int, std::string> m;
 
    // same as m.emplace(10, 20, 'a');
    m.emplace(std::forward_as_tuple(10, std::string(20, 'a')));
    std::cout << "m[10] = " << m[10] << '\n';
 
    // The following is an error: it produces a
    // std::tuple<int&&, std::string&&> holding two dangling references.
    //
    // auto t = std::forward_as_tuple(10, std::string(20, 'a'));
    // m.emplace(t);
}

Output:

m[10] = aaaaaaaaaaaaaaaaaaaa

make_tuple	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)
tie	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)
tuple_cat	crea un tuple mediante la concatenación de cualquier número de tuplas Original: creates a tuple by concatenating any number of tuples 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)