How can I create a macro which uses a value multiple times, without copying it?

Question

I\'d like to create a macro which unpacks a pair into two local variables. I\'d like to not create a copy of the pair if it\'s just a variable, which this would accomplish:<

Answer 1

What you want is std::tie.

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

If you want, you could even use that to define your macro. Note that this will only work for 2-tuples - if you want 3-tuples or more, you'll need to do it a bit differently. For example, if you have a 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;

Answer 2

auto&& creates a forwarding reference, i.e. it accepts anything. It does not (always) create an rvalue reference. So just do this:

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

However, I would strongly suggest against this (unless the scope of the use of UNPACK_PAIR is very limited and the operation is really ubiquitous in that scope). It looks like obscurity for no real benefit to me. Imagine returning to the project after 6 months, with just two hours to find a critical bug. Will you be thanking yourself for using a nonstandard macro-based syntax instead of something readable?

Answer 3

You don't need a macro for this.

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

If you want references to existing members of a pair:

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

That's it.

Now you can move on to something more challenging/interesting/important.