javascript - ¿Cómo puedo emular la desestructuración en C++?

destructuring c++17

Question

En JavaScript ES6, hay una característica de lenguaje conocida como destructuring . También existe en muchos otros idiomas.

En JavaScript ES6, se ve así:

var animal = {
    species: ''dog'',
    weight: 23,
    sound: ''woof''
}

//Destructuring
var {species, sound} = animal

//The dog says woof!
console.log(''The '' + species + '' says '' + sound + ''!'')

¿Qué puedo hacer en C ++ para obtener una sintaxis similar y emular este tipo de funcionalidad?

Answer 1

En C ++ 17 esto se denomina enlaces estructurados , lo que permite lo siguiente:

struct animal {
    std::string species;
    int weight;
    std::string sound;
};

int main()
{
  auto pluto = animal { "dog", 23, "woof" };

  auto [ species, weight, sound ] = pluto;

  std::cout << "species=" << species << " weight=" << weight << " sound=" << sound << "/n";
}

Answer 2

Me temo que no puede tenerlo de la forma en que está acostumbrado en JavaScript (que por cierto parece ser una nueva tecnología en JS ). La razón es que en C ++ simplemente no puede asignar a múltiples variables dentro de una expresión de estructura / objeto / asignación como lo hizo en

var {species, sound} = animal

y luego usar las species y el sound como variables simples . Actualmente C ++ simplemente no tiene esa característica.

Podría asignar a estructuras y / u objetos mientras sobrecarga a su operador de asignación, pero no veo cómo podría emular ese comportamiento exacto (a partir de hoy). Considere las otras respuestas que ofrecen soluciones similares; tal vez eso funciona para su requerimiento.

Answer 3

Otra posibilidad podría hacerse como

#define DESTRUCTURE2(var1, var2, object) var1(object.var1), var2(object.var2)

que se utilizaría como:

struct Example
{
    int foo;
    int bar;
};

Example testObject;

int DESTRUCTURE2(foo, bar, testObject);

Rendiendo variables locales de foo y bar .

Por supuesto, se limita a crear variables del mismo tipo, aunque supongo que podrías usar auto para evitar eso.

Y esa macro se limita a hacer exactamente dos variables. Por lo tanto, deberá crear DESTRUCTURE3, DESTRUCTURE4, etc. para cubrir tantas como desee.

Personalmente no me gusta el estilo de código con el que termina, pero se acerca bastante a algunos aspectos de la característica de JavaScript.

Answer 4

Para el caso específico de objetos std::tuple (o std::pair ), C ++ ofrece la función std::tie que se ve similar:

std::tuple<int, bool, double> my_obj {1, false, 2.0};
// later on...
int x;
bool y;
double z;
std::tie(x, y, z) = my_obj;
// or, if we don''t want all the contents:
std::tie(std::ignore, y, std::ignore) = my_obj;

No soy consciente de un enfoque de la notación exactamente como lo presenta.

Answer 5

Principalmente allí con std::map y std::tie :

#include <iostream>
#include <tuple>
#include <map>
using namespace std;

// an abstact object consisting of key-value pairs
struct thing
{
    std::map<std::string, std::string> kv;
};


int main()
{
    thing animal;
    animal.kv["species"] = "dog";
    animal.kv["sound"] = "woof";

    auto species = std::tie(animal.kv["species"], animal.kv["sound"]);

    std::cout << "The " << std::get<0>(species) << " says " << std::get<1>(species) << ''/n'';

    return 0;
}