CKTIS / C++
std::make_tuple — creare una tupla con tipi dedotti
std::make_tuple di <tuple> crea una tupla i cui tipi degli elementi vengono dedotti dagli argomenti. Normalmente memorizza valori, ma std::ref e std::cref consentono di creare elementi di riferimento invece di copie.
Versione: C++23; repository compiler flag, production runtime not attested
Sintassi
#include <tuple>
template<class... TTypes>
constexpr std::tuple<std::unwrap_ref_decay_t<TTypes>...>
make_tuple(TTypes&&... t);
std::make_tuple(args...)std::make_tuple(args...), fornita da <tuple>, crea una std::tuple senza dover specificare esplicitamente i tipi degli elementi. Ogni argomento inizializza l’elemento corrispondente; i normali lvalue vengono copiati, mentre gli rvalue possono essere spostati se il loro tipo lo consente.
Il tipo di ogni elemento è determinato da std::unwrap_ref_decay_t<TTypes>. Per prima cosa si rimuove l’eventuale riferimento. Se il tipo risultante è un tipo array, si ottiene un puntatore al tipo degli elementi dell’array, di cui si conservano i qualificatori. Se è un tipo funzione, si ottiene un puntatore a una funzione di quel tipo. Solo negli altri casi si rimuovono i qualificatori const e volatile di livello superiore. Per esempio, un letterale stringa ordinario è un array di const char, quindi l’elemento della tupla è di tipo const char*, non char* né std::string.
Dopo questa trasformazione, std::reference_wrapper<T> viene convertito in T&. Usa std::ref(x) per mantenere un riferimento a x, oppure std::cref(x) per mantenere un riferimento a un oggetto costante. La tupla non prolunga la durata dell’oggetto a cui si riferisce tale riferimento; l’oggetto deve esistere ogni volta che il riferimento viene usato.
A differenza di std::make_tuple, std::tie crea una tupla di riferimenti lvalue, mentre std::forward_as_tuple crea una tupla di riferimenti per inoltrare gli argomenti e richiede particolare attenzione con gli oggetti temporanei. Nell’esempio, il primo elemento conserva una copia di 7, mentre il secondo fa riferimento a value. La chiamata std::get<1>(data) si limita a restituire un riferimento a value; è l’operazione += 1 a incrementare value tramite quel riferimento.
Esempi
#include <functional>
#include <iostream>
#include <tuple>
#include <type_traits>
int main() {
int value = 7;
auto data = std::make_tuple(value, std::ref(value));
static_assert(std::is_same_v<decltype(data), std::tuple<int, int&>>);
value = 9;
std::get<1>(data) += 1;
std::cout << std::get<0>(data) << ' '
<< std::get<1>(data) << ' ' << value << '\n';
}
Risultato
7 10 10
Il codice mostrato e il risultato dichiarato sono stati verificati in un ambiente isolato con il metodo registrato nella prova di verifica di questa versione esatta.