CKTIS / C++
Strukturierte Bindungen: `auto [a, b, c]` im Vergleich zu `std::get` und `std::tie`
Mit strukturierten Bindungen erhalten Tupelelemente eigene Namen. Erfahre, wann sie eine Kopie oder das Original bezeichnen und wie sie sich von `std::get` und `std::tie` unterscheiden.
Version: ISO C++23; implementation support may vary
Syntax
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; ist eine Deklaration strukturierter Bindungen: Sie führt drei neue Namen für aufeinanderfolgende Elemente ein. Strukturierte Bindungen gibt es seit C++17; hier gelten die Regeln von ISO C++23. Die Unterstützung kann je nach Implementierung variieren.
In C++23 muss die Anzahl der Namen mit der Anzahl der zerlegten Elemente oder Member übereinstimmen, sonst ist das Programm nicht wohlgeformt. Eingebaute Arrays folgen der Indexreihenfolge, tupelartige Typen dem Protokoll aus std::tuple_size, std::tuple_element und get. Bei anderen geeigneten Klassen gilt die Deklarationsreihenfolge der zugänglichen nichtstatischen Datenmember. Das Tupelprotokoll ruft nicht ausdrücklich std::get auf: Es verwendet ein passendes Member-Template get<I>() oder sucht eine freie Funktion get<I> ausschließlich per argumentabhängiger Namenssuche (ADL).
auto, & und const beziehen sich auf eine verborgene Variable. Für t im Beispiel kopiert auto das Tupel, auto& bindet an das Original, und mit const auto& lassen sich die Elemente ohne Kopie lesen, aber nicht über diese Namen verändern. Beim Kopieren eines Tupels aus Referenzen werden die referenzierten Objekte nicht kopiert. Verwende eine Bindung nicht mehr, nachdem das Objekt, das sie bezeichnet, zerstört wurde.
Bei std::tuple liefert std::get<I>(t) aus <tuple> eine Referenz auf ein Element; der Template-Index beginnt bei null und muss im gültigen Bereich liegen. std::get<T>(t) setzt dagegen voraus, dass T genau einmal vorkommt. std::tie erzeugt ein Tupel aus Referenzen auf vorhandene Objekte; = weist über diese Referenzen zu, und std::ignore überspringt eine Position. Eine strukturierte Bindung deklariert Namen und kann so keine Position überspringen.
Beispiele
#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';
}Ergebnis
copy: 9 get: 7 tie: 7 3
`a = 9` ändert nur die Kopie; `x = 7` ändert das erste Element von `t`. Daher liefert `std::get<0>(t)` den Wert `7`, und die Zuweisung über `std::tie` schreibt `7` nach `first` und `3` nach `last`, ohne das mittlere Element zu übernehmen.
Zugehörige Lektionen
- C++ · Lektion 32 · Mittlere Stufe · Version: 2
Quellen
- 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]