CKTIS / C++
Vinculaciones estructuradas: `auto [a, b, c]` frente a `std::get` y `std::tie`
Pon nombre a los elementos de una tupla con vinculaciones estructuradas. Distingue cuándo se vinculan a una copia o al original y qué hacen `std::get` y `std::tie`.
Versión: ISO C++23; implementation support may vary
Sintaxis
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; es una declaración de vinculaciones estructuradas: introduce tres nombres nuevos para elementos consecutivos. Las vinculaciones estructuradas existen desde C++17; esta ficha sigue ISO C++23 y el grado de compatibilidad puede variar según la implementación.
En C++23, la cantidad de nombres debe coincidir con la de los elementos o miembros que se descomponen; de lo contrario, el programa está mal formado. Los arrays nativos siguen el orden de los índices; los tipos que se comportan como tuplas, el protocolo de std::tuple_size, std::tuple_element y get; las demás clases que cumplen los requisitos, el orden de declaración de sus miembros de datos no estáticos accesibles. El protocolo no llama explícitamente a std::get: utiliza una plantilla miembro get<I>() que cumpla los requisitos o busca una función libre get<I> exclusivamente mediante búsqueda dependiente de los argumentos (ADL).
auto, & y const se aplican a una variable oculta. Para t en el ejemplo, auto copia la tupla, auto& se vincula a la original y const auto& permite leer sus elementos sin copiarla, pero no modificarlos mediante esos nombres. Copiar una tupla de referencias no copia los objetos referenciados. No uses una vinculación después de que se destruya el objeto al que se refiere.
Para std::tuple, std::get<I>(t) de <tuple> devuelve una referencia a un elemento; el índice de plantilla empieza en cero y debe estar dentro del rango. En cambio, std::get<T>(t) exige que T aparezca exactamente una vez. std::tie crea una tupla de referencias a objetos existentes; = asigna valores a través de ellas y std::ignore omite una posición. Una vinculación estructurada declara nombres y no permite omitir una posición de este modo.
Ejemplos
#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` solo cambia la copia; `x = 7` cambia el primer elemento de `t`. Por eso `std::get<0>(t)` da `7` y la asignación mediante `std::tie` escribe `7` en `first` y `3` en `last`, omitiendo el elemento central.
Lecciones relacionadas
- C++ · Lección 32 · Intermedio · Versión: 2
Fuentes
- 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]