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
- WG21 N4950 — Working Draft, Standard for Programming Language C++ (C++23; [dcl.struct.bind], [tuple.elem], [tuple.creation], [tuple.assign])
- Structured binding declarations [dcl.struct.bind] — current working draft; use N4950 for C++23 wording
- Tuple element access [tuple.elem]
- Tuple creation functions [tuple.creation]
- Tuple assignment [tuple.assign]