C++: move / forwarding / rvalue delegation shenanigans [duplicate]

Try running this test program :

#include <iostream> class A { public: A() { std::cout << "empty constructor" << std::endl; } A(const A &a) { std::cout << "copy constructor" << std::endl; } A(A &&a) { std::cout << "move constructor" << std::endl; } ~A() { std::cout << "destructor" << std::endl; } A &operator=(const A &o) { std::cout << "copy assignment" << std::endl; return *this; } A &operator=(A &&o) { std::cout << "move assignment" << std::endl; return *this; } }; A outside; template <typename U> void bar(U &&a) { outside = std::forward<U>(a); } void foo(A &&a) { bar(a); } int main(int argc, char *argv[]) { foo(A()); return 0; } 

On my compiler, I think GCC 4.4.1, the output is:

empty constructor empty constructor copy assignment // what?? destructor destructor 

In my opinion the third line is strange. Why is outside copying a in bar instead of moving it? In other words,hy does foo use the bar(A &a) instantiation of bar instead of bar(A &&a)?

I should mention that this problem is easily fixable by changing foo to

template <typename U> void foo(U &&a) { bar(std::forward<U>(a)); } 

whereupon the move assignment operator is used instead.

In my code I have a lot of delegation methods and I'd hate to have to stick them all in a .h file and make templates for them. Is there another way of telling the compiler or making it understand that a is used as an rvalue in foo?

EDIT: A few people pointed out this change:

void foo(U &&a) { bar(std::move(a)); } 

I was too slow to indicate that I want foo to be able to accept both:

int main(int argc, char *argv[]) { foo(A()); return 0; } 

and

int main(int argc, char *argv[]) { A a; foo(a); return 0; } 

The suggested code will incorrectly steal, in the second case, a's resources in main where it should be used as a reference.