std::forward_as_tuple

 

C++

Linguaggio

Concetti

Libreria di Utilità

Stringhe

Contenitori

Algoritmi

Iteratori

Libreria matematca

Input/output

Localizzazione

Espressioni regolari(C++11)

Operazioni atomicche(C++11)

Multithreading(C++11)

 

Utilità libreria

Tipo di supporto (basic types, RTTI, type traits)

Gestione della memoria dinamica

La gestione degli errori

Programma di utilità

Funzioni variadic

Data e ora

Funzione oggetti

initializer_list (C++11)

bitset

hash (C++11)

Gli operatori relazionali 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>=

Coppie e tuple 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)

Swap, in avanti e spostare 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

Membri funzioni 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

Non membri funzioni 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

Helper classi 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

 

Elemento definito nell'header <tuple>
template<class... Types> tuple<Types...> forward_as_tuple( Types&&... args);		(dal C++11)

Costruisce una tupla di riferimenti agli argomenti in args adatti per la trasmissione come argomento di una funzione. La tupla ha rvalue membri dati di riferimento quando rvalues ​​sono utilizzati come argomenti, e ha altrimenti lvalue membri dati di riferimento. Se rvalues ​​vengono utilizzati, il risultato di questa funzione deve essere consumato prima del punto di sequenza successiva.

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.

Parametri

args

-

zero o più argomenti per costruire la tupla da 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.

Valore di ritorno

Un oggetto creato std::tuple come per 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.

Eccezioni

noexcept specification:  

noexcept

  (dal C++11)

Esempio

#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 oggetto tuple del tipo definito dai tipi di argomenti 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. (funzione di modello)
tie	crea un tuple di riferimenti lvalue o spacchetta una tupla in singoli oggetti 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. (funzione di modello)
tuple_cat	crea un tuple concatenando un numero qualsiasi di tuple 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. (funzione di modello)