move-constructor

The following code snippet causes the copy constructor to be called where I expected the move constructor to be called: #include <cstdio> struct Foo { Foo() { puts("Foo gets built!"); } Foo(const Foo& foo) { puts("Foo gets copied!"); } Foo(Foo&& foo) { puts("Foo gets moved!"); } }; struct Bar { Foo foo; }; Bar Meow() { Bar bar; return bar; } int main() { Bar bar(Meow()); } On VS11 Beta, in debug mode, this prints: Foo gets built! Foo gets copied! Foo gets copied! I checked the standard and Bar seems to meet all requirements to have a default move constructor automatically generated, yet that

Types without a move constructor, but with a copy constructor that accepts const T& arguments, satisfy std::is_move_constructible . For example, in the following code: #include <type_traits> struct T { T(const T&) {} //T(T&&) = delete; }; int main() { static_assert(std::is_move_constructible<T>::value, "not move constructible"); return 0; } T will have no implicit move constructor as it has a user-defined copy constructor. However, if we uncomment the explicit delete of the move constructor, the code no longer compiles. Why is this? I would have expected that the explicit copy constructor

I have two pieces of code here to show you. They are two classes and each one provides a Move Constructor and a function which returns a temporary. In the first case, the function returning a temporary calls the Move Constructor In the second case, the function returning a temporary just tells the compiler to perform a copy elision I'm confused: in both cases I define a Move Constructor and a random member function returning a temporary. But the behavior changes, and my question is why . Note that in the following examples, the operator<< was overloaded in order to print a list (in the first

Minimal working example. #include <cassert> #include <list> #include <queue> //#define USE_PQ struct MyClass { const char* str; MyClass(const char* _str) : str(_str) {} MyClass(MyClass&& src) { str = src.str; src.str = nullptr; } MyClass(const MyClass&) = delete; }; struct cmp_func { bool operator() (const MyClass&, const MyClass&) const { return true; } }; typedef std::priority_queue<MyClass, std::vector<MyClass>, cmp_func> pq_type; #ifdef USE_PQ MyClass remove_front(pq_type& l) { MyClass moved = std::move(l.top()); // error from the above line: // use of deleted function ‘MyClass::MyClass

I'm confused about when a move constructor gets called vs a copy constructor. I've read the following sources: Move constructor is not getting called in C++0x Move semantics and rvalue references in C++11 msdn All of these sources are either overcomplicated(I just want a simple example) or only show how to write a move constructor, but not how to call it. Ive written a simple problem to be more specific: const class noConstruct{}NoConstruct; class a { private: int *Array; public: a(); a(noConstruct); a(const a&); a& operator=(const a&); a(a&&); a& operator=(a&&); ~a(); }; a::a() { Array=new

I have a big class holding a lot of STL containers. Will the compiler automatically make a move constructor that will move those containers to the target or I have to make my own? A move constructor for a class X is implicitly declared as defaulted exactly when X does not have a user-declared copy constructor, X does not have a user-declared copy assignment operator, X does not have a user-declared move assignment operator, X does not have a user-declared destructor, and the move constructor would not be implicitly defined as deleted. So for example, if your class has a class type data member