Enlace estructurado en C++

Requisito previo: Tuplas en C++

El enlace estructurado es una de las funciones más nuevas de C++17 que enlaza los nombres especificados con subobjetos o elementos del inicializador. En palabras simples, los enlaces estructurados nos brindan la capacidad de declarar múltiples variables inicializadas desde una tupla o estructura. El objetivo principal de los enlaces estructurados en C++ 17 es hacer que el código sea limpio y fácil de entender. Al igual que una referencia, un enlace estructurado es un alias de un objeto existente . A diferencia de una referencia, el tipo de enlace estructurado no tiene que ser un tipo de referencia .

Sintaxis:

auto ref-operator(optional)[identifier-list] = expression;

// Or

auto ref-operator(optional)[identifier-list]{expression};

// Or

auto ref-operator(optional)[identifier-list](expression);

Parámetros:

• automático: automático
• operador ref: ya sea & o &&
• lista-identificador: Lista de nombres de variables separados por comas.
• expresión: una expresión que no tiene el operador de coma en el nivel superior (es decir, una expresión de asignación) y tiene un tipo de clase array o no unión.

Deducción de tipo básico:

Sea E el tipo de la expresión inicializadora . E debe ser una especialización de std::tuple , o un tipo cuyos miembros de datos no estáticos sean todos accesibles y se declaren en la misma clase base de E. Una declaración de vinculación estructurada realiza la vinculación en una de tres formas posibles, según una.

• Caso 1 : si E es un tipo de array, los nombres están vinculados a los elementos de la array.
• Caso 2 : si E es un tipo de clase sin unión y tuple_size es un tipo completo, entonces se usa el protocolo de enlace «tipo tupla».
• Caso 3 : si E es un tipo de clase sin unión pero tuple_size no es un tipo completo, entonces los nombres están vinculados a los miembros de datos públicos de E.

Veamos la ventaja de los enlaces de estructura sobre las tuplas con la ayuda de un ejemplo:
Ejemplo 1: en C++98

#include <bits/stdc++.h>
using namespace std;
  
// Creating a structure named Point
struct Point {
    int x;
    int y;
};
  
// Driver code
int main()
{
    Point p = {1, 2};
      
    int x_coord = p.x;
    int y_coord = p.y;
      
    cout << "X Coordinate : " << x_coord << endl;
    cout << "Y Coordinate : " << y_coord << endl;
  
    return 0;
}

Producción :

X Coordinate : 1
Y Coordinate : 2

Ejemplo 2: en C++11/C++14

#include <bits/stdc++.h>
#include <tuple>
using namespace std;
  
// Creating a structure named Point
struct Point
{
    int x, y;
      
    // Default Constructor
    Point() : x(0), y(0) 
    {
          
    }
      
    // Parameterized Constructor for Init List
    Point(int x, int y) : x(x), y(y) 
    {
          
    }
    auto operator()()
    {
        // returns a tuple to make it work with std::tie
        return make_tuple(x, y); 
    }
};
  
// Driver code
int main()
{
    Point p = {1, 2};
    int x_coord, y_coord;
    tie(x_coord, y_coord) = p();
      
    cout << "X Coordinate : " << x_coord << endl;
    cout << "Y Coordinate : " << y_coord << endl;
      
    return 0;
}

Producción :

X Coordinate : 1
Y Coordinate : 2

Ejemplo 3: en C++ 17

#include <bits/stdc++.h>
using namespace std;
  
struct Point
{
    int x;
    int y;
};
  
// Driver code
int main( )
{
    Point p = { 1,2 };
      
    // Structure binding
    auto[ x_coord, y_coord ] = p;
      
    cout << "X Coordinate : " << x_coord << endl;
    cout << "Y Coordinate : " << y_coord << endl;
      
    return 0;
}

Producción :

X Coordinate : 1
Y Coordinate : 2

Aplicaciones: el enlace estructurado se puede usar con arrays para obtener los elementos de la array. En este caso, E es un tipo de array, por lo que los nombres están vinculados a los elementos de la array. A continuación se muestra la implementación para mostrar lo mismo:

#include <bits/stdc++.h>
using namespace std;
  
int main()
{
  
    int arr[3] = { 1, 2, 3 };
      
    // Here, E is an array type, hence the 
    // names are bound to the array elements.
    auto[x, y, z] = arr;
      
    cout << x << " " << y << " " << z << endl;
  
    return 0;
}

Producción :

1 2 3

Nota: el número de identificadores en la lista de identificadores debe ser igual al número de elementos en la array. Si el número de identificadores en la lista de identificadores es menor, puede ocurrir un error de tiempo de compilación o un error de tiempo de diseño. Esto significa que no podemos tomar el conjunto específico de elementos de la array.

Un ejemplo más práctico para usar enlaces estructurados es el siguiente:

#include <bits/stdc++.h>
#include <map>
using namespace std;
  
int main()
{
    // Creating a map with key and value 
    // fields as String
    map<string, string> sites;
      
    sites.insert({ "GeeksforGeeks", "Coding Resources" });
    sites.insert({ "StackOverflow", "Q-A type" });
    sites.insert({ "Wikipedia", "Resources + References" });
  
    for (auto & [ key, value ] : sites) 
    {
       cout << key.c_str() << " " << value.c_str() << endl;
    }
      
    return 0;
}

Producción :

GeeksforGeeks Coding Resources
StackOverflow Q-A type
Wikipedia Resources + References

Nota: Los calificadores como const y volatile se pueden usar junto con type para hacer que la variable de declaración sea constante o volátil.

Para obtener más detalles sobre enlaces estructurados, puede consultar: P0144R0