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

CKTIS / C++

Ligações estruturadas: `auto [a, b, c]` em comparação com `std::get` e `std::tie`

Dá nomes aos elementos de um tuplo com ligações estruturadas. Distingue quando se ligam a uma cópia ou ao original e em que diferem de `std::get` e `std::tie`.

Versão: ISO C++23; implementation support may vary

Sintaxe

auto [a, b, c] = t;
auto& [a, b, c] = t;
const auto& [a, b, c] = t;
// Alternative declarations: use different names or separate scopes.
std::get<0>(t);
std::tie(first, std::ignore, last) = t;

auto [a, b, c] = t; é uma declaração de ligações estruturadas: introduz três nomes novos para elementos consecutivos. As ligações estruturadas existem desde C++17; esta ficha segue a norma ISO C++23 e o suporte pode variar consoante a implementação.

Em C++23, o número de nomes tem de coincidir com o número de elementos ou membros decompostos; caso contrário, o programa está malformado. Os arrays nativos da linguagem seguem a ordem dos índices, os tipos semelhantes a tuplos seguem o protocolo std::tuple_size, std::tuple_element e get, e as restantes classes elegíveis seguem a ordem de declaração dos membros de dados não estáticos acessíveis. O protocolo não chama explicitamente std::get: usa um modelo de função-membro get<I>() que satisfaça os requisitos ou procura uma função livre get<I> apenas por pesquisa dependente dos argumentos (ADL).

auto, & e const aplicam-se a uma variável oculta. Para t no exemplo, auto copia o tuplo, auto& liga-se ao original e const auto& permite ler os elementos sem copiar o tuplo, mas não modificá-los através desses nomes. Copiar um tuplo de referências não copia os objetos referenciados. Não uses uma ligação depois de o objeto que ela designa ter sido destruído.

Para std::tuple, std::get<I>(t) de <tuple> devolve uma referência para um elemento; o índice do modelo começa em zero e tem de estar dentro do intervalo válido. std::get<T>(t) exige que T ocorra exatamente uma vez. std::tie cria um tuplo de referências para objetos existentes; = atribui valores através dessas referências e std::ignore ignora uma posição. Uma ligação estruturada declara nomes e não permite ignorar uma posição desta forma.

Exemplos

#include <iostream>
#include <tuple>

int main() {
    std::tuple<int, int, int> t{1, 2, 3};
    auto [a, b, c] = t;
    auto& [x, y, z] = t;

    a = 9;
    x = 7;

    int first = 0;
    int last = 0;
    std::tie(first, std::ignore, last) = t;

    std::cout << "copy: " << a << '\n';
    std::cout << "get: " << std::get<0>(t) << '\n';
    std::cout << "tie: " << first << ' ' << last << '\n';
}

Resultado

copy: 9
get: 7
tie: 7 3

`a = 9` altera apenas a cópia; `x = 7` altera o primeiro elemento de `t`. Assim, `std::get<0>(t)` dá `7` e a atribuição através de `std::tie` escreve `7` em `first` e `3` em `last`, ignorando o elemento do meio.

Lições relacionadas

  • C++ · Lição 32 · Intermédio · Versão: 2

Fontes