CKTIS / C++
Binding strutturati: `auto [a, b, c]` a confronto con `std::get` e `std::tie`
Assegna un nome agli elementi di una tupla con i binding strutturati. Scopri quando si riferiscono a una copia o all’originale e come differiscono da `std::get` e `std::tie`.
Versione: ISO C++23; implementation support may vary
Sintassi
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; è una dichiarazione di binding strutturati: introduce tre nuovi nomi per elementi consecutivi. I binding strutturati esistono da C++17; questa scheda segue ISO C++23 e il supporto può variare a seconda dell’implementazione.
In C++23 il numero di nomi deve coincidere con quello degli elementi o membri scomposti, altrimenti il programma è mal formato. Gli array nativi seguono l’ordine degli indici, i tipi simili a tuple seguono il protocollo std::tuple_size, std::tuple_element e get, mentre le altre classi idonee seguono l’ordine di dichiarazione dei membri dati non statici accessibili. Il protocollo delle tuple non chiama esplicitamente std::get: usa un template di funzione membro get<I>() che soddisfa i requisiti oppure cerca la funzione non membro get<I> solo tramite la ricerca dipendente dagli argomenti (ADL).
auto, & e const si applicano a una variabile nascosta. Per t nell’esempio, auto copia la tupla, auto& si lega all’originale e const auto& consente di leggerne gli elementi senza copiarli, ma non di modificarli tramite quei nomi. Copiare una tupla di riferimenti non copia gli oggetti referenziati. Non usare un binding dopo la distruzione dell’oggetto a cui si riferisce.
Per std::tuple, std::get<I>(t) da <tuple> restituisce un riferimento a un elemento; l’indice del template parte da zero e deve rientrare nell’intervallo valido. std::get<T>(t) richiede invece che T compaia esattamente una volta. std::tie crea una tupla di riferimenti a oggetti esistenti; = assegna valori attraverso quei riferimenti e std::ignore salta una posizione. Un binding strutturato dichiara nomi e non permette di saltare una posizione in questo modo.
Esempi
#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';
}Risultato
copy: 9 get: 7 tie: 7 3
`a = 9` cambia solo la copia; `x = 7` cambia il primo elemento di `t`. Quindi `std::get<0>(t)` dà `7` e l’assegnazione tramite `std::tie` scrive `7` in `first` e `3` in `last`, saltando l’elemento centrale.
Lezioni correlate
- C++ · Lezione 32 · Intermedio · Versione: 2
Fonti
- 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]