Base de conhecimentoCentro de Exames
PT · PTPortuguês (Portugal)
Escolher idioma13

CKTIS / C++

std::make_tuple — criar uma tupla com tipos deduzidos

std::make_tuple de <tuple> cria uma tupla cujos tipos dos elementos são deduzidos a partir dos argumentos. Normalmente armazena valores, mas std::ref e std::cref permitem criar elementos de referência em vez de cópias.

Versão: C++23; repository compiler flag, production runtime not attested

Sintaxe

#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>, cria um std::tuple sem ser necessário indicar explicitamente os tipos dos elementos. Cada argumento inicializa o elemento correspondente; os lvalues normais são copiados, enquanto os rvalues podem ser movidos se o respetivo tipo o permitir.

O tipo de cada elemento é determinado por std::unwrap_ref_decay_t<TTypes>. Primeiro, remove-se a referência, se existir. Se o tipo resultante for um tipo de array, obtém-se um ponteiro para o tipo dos seus elementos, preservando os qualificadores desse tipo. Se for um tipo de função, obtém-se um ponteiro para uma função desse tipo. Só nos restantes casos se removem os qualificadores const e volatile de nível superior. Por exemplo, um literal de cadeia de caracteres comum é um array de const char, pelo que o elemento da tupla é do tipo const char*, e não char* nem std::string.

Depois dessa transformação, std::reference_wrapper<T> é desembrulhado como T&. Utilize std::ref(x) para manter uma referência a x, ou std::cref(x) para manter uma referência a um objeto constante. A tupla não prolonga o tempo de vida do objeto referido por essa referência; o objeto tem de continuar a existir sempre que a referência for utilizada.

Ao contrário de std::make_tuple, std::tie cria uma tupla de referências lvalue, enquanto std::forward_as_tuple cria uma tupla de referências para encaminhar argumentos e exige especial cuidado com objetos temporários. No exemplo, o primeiro elemento mantém uma cópia de 7, enquanto o segundo se refere a value. A chamada std::get<1>(data) apenas devolve uma referência a value; é a operação += 1 que incrementa value através dessa referência.

Exemplos

#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

O código apresentado e o resultado declarado foram verificados num ambiente isolado pelo método registado na prova de verificação desta versão exata.

Fontes