CKTIS / C++
Gestructureerde bindingen: `auto [a, b, c]` tegenover `std::get` en `std::tie`
Geef tuple-elementen een naam met gestructureerde bindingen. Leer wanneer ze naar een kopie of het origineel verwijzen en hoe ze verschillen van `std::get` en `std::tie`.
Versie: 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; declareert gestructureerde bindingen: het introduceert drie nieuwe namen voor opeenvolgende elementen. Gestructureerde bindingen bestaan sinds C++17; deze uitleg volgt ISO C++23 en de ondersteuning kan per implementatie verschillen.
In C++23 moet het aantal namen gelijk zijn aan het aantal elementen of leden waarin de waarde wordt opgesplitst. Anders is het programma ongeldig. Ingebouwde arrays volgen de indexvolgorde, tupleachtige typen volgen het protocol van std::tuple_size, std::tuple_element en get, en andere geschikte klassen volgen de declaratievolgorde van toegankelijke niet-statische gegevensleden. Het protocol roept niet expliciet std::get aan: het gebruikt een geschikte lidfunctietemplate get<I>() of zoekt een vrije functie get<I> uitsluitend met argumentafhankelijke naamopzoeking (ADL).
auto, & en const horen bij een verborgen variabele. Voor t in het voorbeeld kopieert auto de tuple, bindt auto& aan het origineel en kun je met const auto& elementen lezen zonder te kopiëren, maar ze niet via die namen wijzigen. Het kopiëren van een tuple met referenties kopieert de objecten waarnaar die referenties verwijzen niet. Gebruik een binding niet nadat het object waarnaar die verwijst is vernietigd.
Voor std::tuple geeft std::get<I>(t) uit <tuple> een referentie naar één element; de template-index begint bij nul en moet binnen het geldige bereik vallen. std::get<T>(t) vereist dat T precies één keer voorkomt. std::tie maakt een tuple van referenties naar bestaande objecten; = wijst waarden toe via die referenties en std::ignore slaat een positie over. Een gestructureerde binding declareert namen en kan op die manier geen positie overslaan.
Voorbeelden
#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';
}Resultaat
copy: 9 get: 7 tie: 7 3
`a = 9` wijzigt alleen de kopie; `x = 7` wijzigt het eerste element van `t`. Daarom geeft `std::get<0>(t)` de waarde `7` en schrijft de toewijzing via `std::tie` `7` naar `first` en `3` naar `last`, met overslaan van het middelste element.
Gerelateerde lessen
- C++ · Les 32 · Gemiddeld · Versie: 2
Bronnen
- 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]