[…] will the compiler be able to optimize away the extra initializations? In almost all cases: yes. Should I always write my move constructors by calling the move assignment operator? Yes, just implement it via move assignment operator, except in the cases where you measured that it leads to suboptimal performance. Today’s optimizer do an … Read more
This is why you should not declare said member variables const. const member variables usually serve no purpose. If you don’t want users to mutate the FILE*, then don’t provide them with functions to do that, and if you want to stop yourself from mutating it by accident, then mark your functions const. However, do … Read more
You take each one by value, like this: struct foo { foo(std::string s, bar b, qux q) : mS(std::move(s)), mB(std::move(b)), mQ(std::move(q)) {} std::string mS; bar mB; qux mQ; }; The initialization of the function parameters by the argument will either be a copy-constructor or move-constructor. From there, you just move the function parameter values into … Read more
An explicit move constructors can affect compatibility with e.g. Standard algorithms. For instance, std::swap<T> requires that T be MoveConstructible. In turn, MoveConstructible is specified in terms of an expression, namely T u = rv; (where rv is an rvalue of type T). If there is neither a non-explicit copy constructor nor a non-explicit move constructor … Read more
A move constructor is called: when an object initializer is std::move(something) when an object initializer is std::forward<T>(something) and T is not an lvalue reference type (useful in template programming for “perfect forwarding”) when an object initializer is a temporary and the compiler doesn’t eliminate the copy/move entirely when returning a function-local class object by value … Read more
They don’t need to be cleaned. The designer of the class decided it would be a good idea to leave the moved-from object zero initialized. Note that a situation where is does make sense is for objects managing resources that get released in the destructor. For instance, a pointer to dynamically allocated memory. Leaving the … Read more
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 … 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).
Because: A defaulted move constructor that is defined as deleted is ignored by overload resolution. ([class.copy]/11) Bar‘s move constructor is explicitly deleted, so Bar cannot be moved. But Foo<Bar>‘s move constructor is implicitly deleted after being implicitly declared as defaulted, due to the fact that the Bar member cannot be moved. Therefore Foo<Bar> can be … Read more
Let’s start with a bit of code: class A { using MutexType = std::mutex; using ReadLock = std::unique_lock<MutexType>; using WriteLock = std::unique_lock<MutexType>; mutable MutexType mut_; std::string field1_; std::string field2_; public: … I’ve put some rather suggestive type aliases in there that we won’t really take advantage of in C++11, but become much more useful in … Read more