Jak mogę emulować destructuring w C++?

Question

W języku JavaScript ES6 dostępna jest funkcja językowa o nazwie destructuring. Istnieje również w wielu innych językach.

w JavaScript ES6, wygląda to tak:

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

//Destructuring 
var {species, sound} = animal 

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

Co mogę zrobić w C++, aby uzyskać podobną składnię i naśladować tego rodzaju funkcjonalność?

Answer 1

Dla konkretnego przypadku std::tuple (lub std::pair) obiektów, C++ oferuje funkcję std::tie który wygląda podobnie:

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; 

Nie znam podejścia do zapisu dokładnie tak, jak je przedstawiasz.

Answer 2

Głównie tam z std::map i 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; 
} 

Answer 3

Obawiam się, że nie można mieć tego w sposób, do jakiego przyzwyczaiłeś się w JavaScript (a tak przy okazji, wydaje się być new technology in JS). Powodem jest to, że w C++ po prostu nie można przypisać do wielu zmiennych w wyrażeniu struktura/przedmiot/przypisania jak ty w

var {species, sound} = animal 

a następnie użyć species i sound jak prostych zmiennych. Obecnie C++ po prostu nie ma tej funkcji.

Można przypisać do struktur i/lub obiektów podczas przeciążania ich operatora przypisania, ale nie widzę sposobu, w jaki można naśladować to dokładne zachowanie (od dzisiaj). Rozważ inne odpowiedzi oferujące podobne rozwiązania; może to działa na twoją potrzebę.

Answer 4

Inną możliwością mogłoby być wykonane jako

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

które mogą być użyte, jak:

struct Example 
{ 
    int foo; 
    int bar; 
}; 

Example testObject; 

int DESTRUCTURE2(foo, bar, testObject); 

otrzymując zmienne lokalne foo i bar.

Oczywiście ogranicza się to do tworzenia zmiennych tego samego typu, chociaż przypuszczam, że można użyć do tego celu auto.

To makro jest ograniczone do zrobienia dokładnie dwóch zmiennych. Musisz więc stworzyć DESTRUCTURE3, DESTRUCTURE4 i tak dalej, aby pokryć tak dużo, jak tylko chcesz.

Nie osobiście podoba mi się styl kodowy, który kończy się, ale jest dość zbliżony do niektórych aspektów funkcji JavaScript.

Answer 5

w C++ 17 nazywa się to structured bindings, która pozwala na następujące cele:

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"; 
}