Base de conocimientosCentro de exámenes
ESEspañol
Elegir idioma13

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