Come posso creare una macro che usa un valore più volte, senza copiarlo?

Question

Vorrei creare una macro che decomprimi una coppia in due variabili locali. Mi piacerebbe non creare una copia della coppia se è solo una variabile, che quest'anno avrebbe compiuto:

#define UNPACK_PAIR(V1, V2, PAIR) \ 
    auto& V1 = PAIR.first; \ 
    auto& V2 = PAIR.second; 

UNPACK_PAIR(one, two, x); 

Tuttavia, mi piacerebbe anche di non valutare l'espressione è dato più volte, ad esempio, questo dovrebbe solo chiamare expensive_computation() volta:

UNPACK_PAIR(one, two, expensive_computation()); 

Se lo faccio:

#define UNPACK_PAIR_A(V1, V2, PAIR) \ 
    auto tmp = PAIR; \ 
    auto& V1 = tmp.first; \ 
    auto& V2 = tmp.second; 

allora funziona per il caso expensive_computation(), ma rende una copia nel caso x. Se faccio:

#define UNPACK_PAIR_R(V1, V2, PAIR) \ 
    auto& tmp = PAIR; \ 
    auto& V1 = tmp.first; \ 
    auto& V2 = tmp.second; 

allora funziona nel caso x senza fare una copia, ma non riesce nel caso expensive_computation(). Se faccio:

#define UNPACK_PAIR_CR(V1, V2, PAIR) \ 
    const auto& tmp = PAIR; \ 
    auto& V1 = tmp.first; \ 
    auto& V2 = tmp.second; 

#define UNPACK_PAIR_RR(V1, V2, PAIR) \ 
    auto&& tmp = PAIR; \ 
    auto& V1 = tmp.first; \ 
    auto& V2 = tmp.second; 

Questi sia compilare ed eseguire, ma ho il sospetto che invocano un comportamento indefinito - Ho ragione a tale proposito? Inoltre, uno di questi avrebbe senso?

#define UNPACK_PAIR_RR(V1, V2, PAIR) \ 
    auto&& tmp = std::move(PAIR); \ 
    auto& V1 = tmp.first; \ 
    auto& V2 = tmp.second; 

#define UNPACK_PAIR_RR(V1, V2, PAIR) \ 
    auto&& tmp = std::forward<decltype(PAIR)>(PAIR); \ 
    auto& V1 = tmp.first; \ 
    auto& V2 = tmp.second; 

---

Esiste un modo per creare una macro che funziona per entrambi i casi d'uso - non copiare x ancora, inoltre, non invocando un comportamento indefinito quando dato il risultato di una chiamata di un'espressione o una funzione?

Answer 1

auto&& crea un riferimento di inoltro, vale a dire accetta qualsiasi cosa. Fa non (sempre) crea un riferimento di rvalue. Quindi, solo fare questo:

#define UNPACK_PAIR(V1, V2, PAIR) \ 
    auto&& tmp = PAIR; \ 
    auto& V1 = tmp.first; \ 
    auto& V2 = tmp.second; 

Tuttavia, vi consiglierei vivamente contro questo (a meno che il campo di applicazione della uso di UNPACK_PAIR è molto limitato ed il funzionamento è davvero onnipresente in tale ambito). Sembra un'oscurità senza alcun beneficio reale per me. Immagina di tornare al progetto dopo 6 mesi, con solo due ore per trovare un bug critico. Ti ringrazerai per l'utilizzo di una sintassi non standard basata su macro invece di qualcosa di leggibile?

Answer 2

Non è necessaria una macro per questo.

auto p = std::make_pair(2, 3); 
int x, y; 
std::tie(x, y) = p; 

Se si desidera riferimenti a membri esistenti di una coppia:

auto p = std::make_pair(2, 3); 
auto& x = p.first; 
auto& y = p.second; 

Questo è tutto.

Ora puoi passare a qualcosa di più impegnativo/interessante/importante.

Answer 3

Quello che desideri è std::tie.

decltype(p.first) x; 
decltype(p.second) y; 
std::tie(x,y) = p; 

Se lo desideri, puoi anche usarlo per definire la tua macro. Nota che questo funzionerà solo con le tuple da 2, se vuoi le tuple da 3 o più, dovrai farlo un po 'diversamente.Ad esempio, se si dispone di un 3-tuple t:

decltype(std::get<0>(t)) x; 
decltype(std::get<1>(t)) y; 
decltype(std::get<2>(t)) z; 
std::tie(x,y,z) = t;