CKTIS / C++
Liaisons structurées : `auto [a, b, c]`, `std::get` et `std::tie`
Nommez les éléments d’un tuple avec des liaisons structurées. Distinguez les liaisons à une copie ou à l’original des opérations offertes par `std::get` et `std::tie`.
Version : ISO C++23; implementation support may vary
Syntaxe
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; est une déclaration de liaisons structurées : elle introduit trois nouveaux noms pour les éléments successifs. Les liaisons structurées existent depuis C++17 ; cette fiche suit ISO C++23 et la prise en charge peut varier selon l’implémentation.
En C++23, le nombre de noms doit correspondre au nombre d’éléments ou de membres décomposés, sinon le programme est mal formé. Les tableaux natifs suivent l’ordre des indices, les types assimilables à des tuples suivent le protocole std::tuple_size, std::tuple_element et get, et les autres classes admissibles suivent l’ordre de déclaration des membres de données non statiques accessibles. Le protocole des tuples n’appelle pas explicitement std::get : il utilise un modèle de fonction membre get<I>() qui satisfait aux critères, ou recherche une fonction non membre get<I> uniquement par recherche dépendante des arguments (ADL).
auto, & et const s’appliquent à une variable cachée. Pour t dans l’exemple, auto copie le tuple, auto& se lie à l’original et const auto& permet de lire les éléments sans copie, mais pas de les modifier par ces noms. Copier un tuple de références ne copie pas les objets référencés. N’utilisez pas une liaison après la destruction de l’objet qu’elle désigne.
Pour std::tuple, std::get<I>(t) dans <tuple> renvoie une référence à un élément ; l’indice du modèle commence à zéro et doit être valide. std::get<T>(t) exige que T apparaisse exactement une fois. std::tie crée un tuple de références à des objets existants ; = affecte les valeurs via ces références et std::ignore saute une position. Une liaison structurée déclare des noms et ne permet pas d’ignorer une position de cette façon.
Exemples
#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';
}Résultat
copy: 9 get: 7 tie: 7 3
`a = 9` ne modifie que la copie ; `x = 7` modifie le premier élément de `t`. Ainsi, `std::get<0>(t)` donne `7` et l’affectation via `std::tie` écrit `7` dans `first` et `3` dans `last`, en ignorant l’élément du milieu.
Leçons associées
- C++ · Leçon 32 · Intermédiaire · Version : 2
Sources
- 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]