move-semantics

This is a follow-up of Explicit ref-qualified conversion operator templates in action . I have experimented with many different options and I am giving some results here in an attempt to see if there is any solution eventually. Say a class (e.g. any ) needs to provide conversion to any possible type in a convenient, safe (no surprises) way that preserves move semantics. I can think of four different ways. struct A { // explicit conversion operators (nice, safe?) template<typename T> explicit operator T&& () &&; template<typename T> explicit operator T& () &; template<typename T> explicit

Copy-assignment for a class with a reference member variable is a no-no because you can't reassign the reference. But what about move-assignment? I tried simply move ing it but, of course, that destroys the source object when I just want to move the reference itself: class C { public: C(X& x) : x_(x) {} C(C&& other) : x_(std::move(other.x_)) {} C& operator=(C&& other) { x_ = std::move(other.x_); } private: X& x_; }; X y; C c1(y); X z; C c2(z); c2 = c1; // destroys y as well as z Should I just not be implementing move-assignment and sticking with move-construction only? That makes swap(C&, C&)

Could you guys give me an illustrative example under certain circumstance to prove the following statements are useful and necessary? AnyTypeMovable v; AnyTypeMovable&& r = move(v); Nemanja Boric No, AnyTypeMovable&& r = move(v); here is not useful at all. Consider the following code: #include <iostream> #include <vector> class MyMovableType { int i; public: MyMovableType(int val): i(val){} MyMovableType(MyMovableType&& r) { this->i = r.i; r.i = -1; } MyMovableType(const MyMovableType& r){ this->i = r.i; } int getVal(){ return i; } }; int main() { std::vector<MyMovableType> vec; MyMovableType