It’s a great question which foxes almost everyone in the beginning. template <class T> class A { template <class U> void foo(T&& t, U&& u); }; In this example, T is not deduced (you explicitly define it when you instanciate the template). U is deduced because it’s deduced from the argument u. Therefore, in almost … Read more
My take on this. 20.8.10.1.2/10 in N3225 The values of the bound arguments v1, v2, …, vN and their corresponding types V1, V2, …, VN depend on the types TiD derived from the call to bind and the cv-qualifiers cv of the call wrapper g as follows: if TiD is reference_wrapper, the argument is tid.get() … Read more
On the usefulness of const&&… (in general) The usefulness of the const&& qualifier on the member method is minimal at best. The object cannot be modified in the same manner as a && method would allow it to be modified; it is const after all (as noted, mutable does change this). So we will not … Read more
It does bind to the overload of std::forward taking an lvalue: template <class T> constexpr T&& forward(remove_reference_t<T>& t) noexcept; It binds with T == int. This function is specified to return: static_cast<T&&>(t) Because the T in f deduced to int. So this overload casts the lvalue int to xvalue with: static_cast<int&&>(t) Thus calling the g(int&&) … Read more
Recycling temporaries is an interesting idea and you’re not the only one who wrote functions that return rvalue references for this reason. In an older C++0x draft operator+(string&&,string const&) was also declared to return an rvalue reference. But this changed for good reasons. I see three issues with this kind of overloading and choice of … Read more
Your class A has several issues: Your assignment operator don’t handle self assignment and leak: A& A::operator=(const A& a) { std::cout<<“overload operator=\n”; if (this != &a) { p = a.p; delete[] s; s = new char[strlen(a.s) + 1]; strcpy(s, a.s); } return *this; } Your move doesn’t move but copy: A::A(A&& a) : p(a.p), s(a.s) … Read more
Have the assignment operator be callable on lvalues only: class C { // … public: C& operator=(const C&) & = default; }; Note the single ampersand after the closing parenthesis. It prevents assigning to rvalues.
I always remember lvalue as a value that has a name or can be addressed. Since x has a name, it is passed as an lvalue. The purpose of reference to rvalue is to allow the function to completely clobber value in any way it sees fit. If we pass x by reference as in … Read more
Put noexcept on your move constructor: TestClass(TestClass&& other) noexcept { Elaboration: I was going to give this one Pierre, but unfortunately the cppreference source is only approximately correct. In C++03 vector<T>::push_back(T) has the “strong exception guarantee”. That means that if the push_back throws an exception, the vector is left in the same state it had … Read more
It should be a non-const rvalue reference. If an object is placed in read-only memory, you can’t steal resources from it, even if its formal lifetime is ending shortly. Objects created as const in C++ are allowed to live in read-only memory (using const_cast to try to change them results in undefined behavior).