That seems to be an oversight in the design of std::priority_queue<T>. There doesn’t appear to be a way to directly move (not copy) an element out of it. The problem is that top() returns a const T&, so that cannot bind to a T&&. And pop() returns void, so you can’t get it out of … Read more
It’s specifically because you use an initializer list that the copy-constructor is used. The initializer list is initialized with a copy of the object, and then passed to the vector. If you read the linked reference, from C++14 it even explicitly say … each element is copy-initialized … from the corresponding element of the original … Read more
Update: Explicit move should not be needed in modern compiler versions. Core DR 1579 changed the rules so that the return value will be treated as an rvalue even when the types are not the same. GCC 5 implements the new rule, for C++11 as well as C++14. Original answer: This is not a limitation … Read more
First of all, it is generally unnecessary to write a swap function in C++11 as long as your class is movable. The default swap will resort to moves: void swap(T& left, T& right) { T tmp(std::move(left)); left = std::move(right); right = std::move(tmp); } And that’s it, the elements are swapped. Second, based on this, the … Read more
No, a defaulted destructor is still considered user defined, so it will prevent the generation of move operations. Also declare the move operations default-ed to make the compiler generate them. You need to only declare the move operations as default-ed in the base class. In the derived class, the destructor won’t be user defined anymore … Read more
You can write your function like this: fn take<T>(mut vec: Vec<T>, index: usize) -> Option<T> { if vec.get(index).is_none() { None } else { Some(vec.swap_remove(index)) } } The code you see here (get and swap_remove) is guaranteed O(1). However, kind of hidden, vec is dropped at the end of the function and this drop operation is … Read more
std::array is movable only if its contained objects are movable. std::array is quite different from the other containers because the container object contains the storage, not just pointers into the heap. Moving a std::vector only copies some pointers, and the contained objects are none the wiser. Yes, std::array uses the default move constructor and assignment … 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
Herb’s answer (before it was edited) actually gave a good example of a type which shouldn’t be movable: std::mutex. The OS’s native mutex type (e.g. pthread_mutex_t on POSIX platforms) might not be “location invariant” meaning the object’s address is part of its value. For example, the OS might keep a list of pointers to all … Read more
The compiler may NRVO into a temp space, or move construct into a temp space. From there it will move assign x. Update: Any time you’re tempted to optimize with rvalue references, and you’re not positive of the results, create yourself an example class that keeps track of its state: constructed default constructed moved from … Read more