C++ multiple forwarding of one reference: first copy and then move

Question

Consider the following code, where the same reference is forwarded two times to a base class and used there to construct a tuple:

template<typename ... Ts>
struct Base
{
    template<typename ... _Ts>
    Base(_Ts&& ... ts) : tup{std::forward<_Ts>(ts) ...} {}

    std::tuple <Ts ...> tup;
};

template<typename T>
struct Derived : public Base<T, T>
{
    template<typename _T>
    Derived(_T&& t) : Base<T, T>{t, std::forward<_T>(t)} {}
};

Calling first the base class constructor in Derived as Base<T, T>{t, std::forward<_T>(t)} and thereafter also the tuple constructor using tup{std::forward<Ts>(ts)...} has the following reason:

When t is an rvalue reference, the first tuple argument shall be passed an lvalue-ref to t and thus be constructed through a copy of t, whereas the second tuple element should get an rvalue-ref and therefore, if possible, use a move for construction.

This approach seems to be supported by several questions and answers on SO (e.g. here, here and here) which state that the braced-init list performs to a left-to-right evaluation of its arguments.

However, when I use the above code in a simple example, the actual behavior is (consistently) the opposite of what I expected:

struct A
{
    A() = default;
    A(A const& other) : vec(other.vec) { std::cout<<"copy"<<std::endl; }
    A(A && other) : vec(std::move(other.vec)) { std::cout<<"move"<<std::endl; }

    std::vector<int> vec = std::vector<int>(100);
};

int main()
{
    Derived<A> d(A{});  //prints first "move", then "copy"

    std::cout<<std::get<0>(d.tup).vec.size()<<std::endl;  //prints 0
    std::cout<<std::get<1>(d.tup).vec.size()<<std::endl;  //prints 100
}

Here is the example using gcc on Coliru. (The gcc compiler apparently had a bug once in this connection, but it's about two years since and should be no issue anymore.)

Questions:

Where am I wrong on the implementation or the assumptions here?
How can the above code be fixed to behave as expected: first copy -- then move?

any symbol beginning with an underscore followed by a capital letter is reserved for the implementation; change `_T` and `_Ts` to something else. — Ryan Haining, Feb 11 '16 at 18:44

score 2 · Answer 1 · answered Feb 11 '16 at 18:44

2

You should do the copy explicitly, else you pass a reference which is later used by copy (but, with the alias, may have been moved):

template<typename U>
struct Derived : public Base<U, U>
{
    template<typename T>
    Derived(T&& t) : Base<U, U>{T(t), std::forward<T>(t)} {}
};

Demo

answered Feb 11 '16 at 18:44

Jarod42

203,559
14
181
302

Nice trick: This should work (arguments being functions are called before passing the result to the constructor and std::forward is just a cast) – Feb 11 '16 at 18:57

Claudiu · Accepted Answer · 2016-02-11T18:45:05.590

I'm not sure the order-of-operations on the object initializations matter. Due to the perfect forwarding, no copies or moves are actually made (i.e. only lvalue references and rvalue references are passed around) until the std::tuple constructor is called. And, at that point, it depends on the implementation details of std::tuple.

Consider if instead of std::tuple you used the following my_tup struct:

template<typename T1, typename T2>
struct my_tup
{
    template <typename A, typename B>
    my_tup(A&& a, B&& b) 
        : t1(std::forward<A>(a)), t2(std::forward<B>(b))
    {
    }

    T1 t1;
    T2 t2;
};

This prints, as expected, "copy" and then "move" (coliru). But if instead you have:

template<typename T1, typename T2>
struct my_tup
{
    template <typename A, typename B>
    my_tup(A&& a, B&& b) 
        : t2(std::forward<B>(b)), t1(std::forward<A>(a))
    {
    }

    T2 t2;
    T1 t1;
};

Then this prints "move", then "copy", as std::tuple does (coliru).

Likely due to the way the variadic template is expanded, std::tuple must be dealing with the arguments in a right-to-left manner. I am not sure whether this is implementation-dependent or specified in the spec.

Thanks, that's the answer I guess. Evaluation does not mean construction. And a corresponding tuple construction constraint in the standard does not seem to exist. — davidhigh, Feb 11 '16 at 19:01
See also [this answer](http://stackoverflow.com/questions/32192809/tuple-isnt-being-constructed-in-order) which states that there is no standard order in the tuple construction. — davidhigh, Feb 12 '16 at 10:10

C++ multiple forwarding of one reference: first copy and then move

2 Answers2