rvalue-reference

There is this code: #include <iostream> class F { public: F() = default; F(F&&) { std::cout << "F(F&&)" << std::endl; } F(F&) { std::cout << "F(F&)" << std::endl; } }; class G { F f_; public: G(F&& f) : f_(f) { std::cout << "G()" << std::endl; } }; int main(){ G g = F(); return 0; } The output is: F(F&) G() Why F(F&) constructor is called instead of F(F&&) constructor in constructor of class G ? The parameter for constructor of class G is F&& f which is rvalue reference but constructor for lvalue reference is called. Why F(F&) constructor is called instead of F(F&&) constructor in constructor

I'm trying to make a form of std::thread that puts a wrapper around the code executed in the thread. Unfortunately I can't get it to compile due likely to my poor understanding of rvalues and the Function templated type I'm trying to pass. Here's my code: #include <vector> #include <thread> #include <utility> void Simple2(int a, int b) {} template <typename Function, typename... Args> void Wrapper(Function&& f, Args&&... a) { f(std::forward<Args>(a)...); } class Pool { public: template <typename Function, typename... Args> void Binder(Function&& f, Args&&... a) { std::thread t(Wrapper<Function

Is there a reason when a function should return a RValue Reference ? A technique, or trick, or an idiom or pattern? MyClass&& func( ... ); I am aware of the danger of returning references in general, but sometimes we do it anyway, don't we ( T& T::operator=(T) is just one idiomatic example). But how about T&& func(...) ? Is there any general place where we would gain from doing that? Probably different when one writes library or API code, compared to just client code? There are a few occasions when it is appropriate, but they are relatively rare. The case comes up in one example when you want

I am reading about the std::move , move constructor and move assignment operator. To be honest, all I got now is confusion. Now I have a class: class A{ public: int key; int value; A(){key = 3; value = 4;} //Simple move constructor A(A&& B){ A.key = std::move(B.key); A.value = std::move(B.value);} }; I thought B is an rvalue reference, why you can apply std::move to an ravlue reference's member? After B.key and B.value have been moved, both have been invalidated, but how B as an object of class A gets invalidated? What if I have A a(A()) , A() is apparently an rvlaue, can A() be moved by std:

Trying to learn lvalues , rvalues and memory allocation for them. So with a lot of learning materials there is a bit of chaos. An rvalue is a value that needs to exist only in bounds of a expression where it was created (until C++11 at least). So it has an address and block of memory that it occupies. But by definition we cannot get an address of rvalue , because it is a temporary object in contrast to an lvalue . But even before C++11 we were able to get an address of rvalue by returning it from a function and saving it into a const reference type (uh, I guess not an address but a value). So,

I have the following test program: #include <iostream> #include <type_traits> #include <utility> template<typename Ty, std::size_t N> void foo(Ty (&&)[N]) { std::cout << "Ty (&&)[" << N << "]\t" << std::is_const<Ty>::value << '\n'; } template<typename Ty, std::size_t N> void foo(Ty (&)[N]) { std::cout << "Ty (&)[" << N << "]\t" << std::is_const<Ty>::value << '\n'; } template<typename Ty> using id = Ty; int main() { std::cout.setf(std::cout.boolalpha); foo(id<int[]>{1, 2, 3, 4, 5}); foo(id<int const[]>{1, 2, 3, 4, 5}); // <-- HERE. int xs[]{1, 2, 3, 4, 5}; foo(xs); int const ys[]{1, 2, 3, 4, 5}