CKTIS / C++
std::make_tuple — crear una tupla con tipos deducidos
std::make_tuple de <tuple> crea una tupla cuyos tipos de elemento se deducen a partir de los argumentos. Normalmente almacena valores, pero std::ref y std::cref permiten crear elementos de referencia en lugar de copias.
Versión: C++23; repository compiler flag, production runtime not attested
Sintaxis
#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...), de <tuple>, crea un std::tuple sin tener que escribir explícitamente los tipos de sus elementos. Cada argumento inicializa el elemento correspondiente; los lvalues normales se copian, mientras que los rvalues pueden moverse si su tipo lo permite.
El tipo de cada elemento se determina mediante std::unwrap_ref_decay_t<TTypes>. Primero se elimina la referencia, si la hay. Si el tipo resultante es un tipo de array, se obtiene un puntero al tipo de sus elementos, que conserva sus calificadores. Si es un tipo de función, se obtiene un puntero a una función de ese tipo. Solo en los demás casos se eliminan los calificadores const y volatile de nivel superior. Por ejemplo, un literal de cadena ordinario es un array de const char, por lo que el elemento de la tupla es de tipo const char*, no char* ni std::string.
Después de esa transformación, std::reference_wrapper<T> se desempaqueta como T&. Usa std::ref(x) para conservar una referencia a x, o std::cref(x) para conservar una referencia a un objeto constante. La tupla no prolonga la vida del objeto al que hace referencia; dicho objeto debe seguir existiendo cada vez que se use la referencia.
A diferencia de std::make_tuple, std::tie crea una tupla de referencias lvalue, mientras que std::forward_as_tuple crea una tupla de referencias para reenviar argumentos y exige especial cuidado con los objetos temporales. En el ejemplo, el primer elemento conserva una copia de 7, mientras que el segundo hace referencia a value. La llamada std::get<1>(data) solo devuelve una referencia a value; es la operación += 1 la que incrementa value a través de esa referencia.
Ejemplos
#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';
}
Resultado
7 10 10
El código mostrado y el resultado declarado se verificaron en un entorno aislado mediante el método registrado en la evidencia de verificación de esta versión exacta.