move-semantics

Consider the following: class Example : boost::noncopyable { HANDLE hExample; public: Example() { hExample = InitializeHandle(); } ~Example() { if (hExample == INVALID_HANDLE_VALUE) { return; } FreeHandle(hExample); } Example(Example && other) : hExample(other.hExample) { other.hExample = INVALID_HANDLE_VALUE; } Example& operator=(Example &&other) { std::swap(hExample, other.hExample); //? return *this; } }; My thinking here is that the destructor will be running on "other" shortly, and as such I don't have to implement my destructor logic again in the move assignment operator by using swap.

Something told me how to implement a linked list: enum List { Cons(u32, Box<List>), Nil, } impl List { fn prepend(self, elem: u32) -> List { Cons(elem, Box::new(self)) } } When I want to use prepend , I need to do the following: list = list.prepend(1); However, I want to create a function that does not need to create a new variable every time prepend returns. I just want to change the list variable itself using prepend : list.prepend(1); Here is one implementation that I come up with, but it's not right: fn my_prepend(&mut self, elem: u32) { *self = Cons(elem, Box::new(*self)); } The error is:

I've been led to understand that calling a member function on the contents of a moved-from std::unique_ptr is undefined behaviour. My question is: if I call .get() on a unique_ptr and then move it, will the original .get() pointer continue to point to the contents of the original unique pointer? In other words, std::unique_ptr<A> a = ... A* a_ptr = a.get(); std::unique_ptr<A> a2 = std::move(a); // Does *a_ptr == *a2? I think it does, but I want to make sure. ('contents' is probably the wrong word. I mean the data you get when you dereference the pointer) Merely moving the unique_ptr only

#include <type_traits> template<class T> typename std::remove_reference<T>::type&& move(T&& v) { return v; } void main() { int a; move(a); } Why doesn't this code compile? error C2440: 'return' : impossible to convert 'int' in 'int &&' This is straight out of the C++0x draft standard (§20.2.3/6): template <class T> typename remove_reference<T>::type&& move(T&& t) noexcept; Returns : static_cast<typename remove_reference<T>::type&&>(t) . Consequently, if you change your move implementation to the following, it works just fine: template<class T> typename std::remove_reference<T>::type&& move(T&&

I'm trying to construct an object in a map that contains an atomic, so it can neither be copied nor moved AFAICT. My reading of C++ reference is that map emplace should be able to do this. But the following code does not compile because of deleted or non-existent constructors. Using make_pair does not help. #include <atomic> #include <unordered_map> class Z { std::atomic<int> i; }; std::unordered_map<int, Z> map; void test(void) { map.emplace(0, Z()); // error map[0] = Z(); // error } Is this possible, and if not, why not? EDIT: Compiler is gcc 4.8.1, on Linux map.emplace(std::piecewise

If you look at get , the helper function for std::tuple , you will notice the following overload: template< std::size_t I, class... Types > constexpr std::tuple_element_t<I, tuple<Types...> >&& get( tuple<Types...>&& t ); In other words, it returns an rvalue reference when the input tuple is an rvalue reference itself. Why not return by value, calling move in the function body? My argument is as follows: the return of get will either be bound to a reference, or to a value (it could be bound to nothing I suppose, but this shouldn't be a common use case). If it's bound to a value, then a move