Alternative to initializer_list of references for temporary referential sequences?

{ edited by mod to wrap long lines at ~70 chars. -mod }

Hi all,

I'm trying to come up with a simple solution for creating temporary,
incidental, *referential* sequences.

I want to be able to do something akin to this:
    int a{1}, b{2}, c{3};
    for (auto&& i : {a, b, c})
        i *= 2;

This isn't possible due to the copy-initialization of std::initializer_list
(which here yields a sequence of immutable ints). In my actual use case
the elements are unique_ptr instantiations (of common type), so the
initializer_list can't even be constructed due to non-copyability of
unique_ptr.

An obvious alternative is to store the objects (a, b, c) in some container,
but doing so loses the symbolic meaning of the variable names, which is
more important to readability.

The simplest thing I could come up with is this:
    template<class T>
    using ref_seq = std::initializer_list<std::reference_wrapper<T>>;

    int a{1}, b{2}, c{3};
    for (auto&& i : ref_seq<int>{a, b, c})
        i *= 2;

For any operation for which the implicit conversion to int isn't usable,
i.get() would have to be called.

I don't think it's possible to employ type deduction here: AFAICT the only
thing that can be used to type-deduce from a braced-init-list is
std::initializer_list, which doesn't deduce references.

Does anyone have any improvement on the above, particularly if it enables
use of type-deduction or avoids necessity of reference_wrapper::get()?

TIA --rob

--
      [ See http://www.gotw.ca/resources/clcm.htm for info about ]
      [ comp.lang.c++.moderated. First time posters: Do this! ]