1. “What is it?” While std::move() is technically a function – I would say it isn’t really a function. It’s sort of a converter between ways the compiler considers an expression’s value. 2. “What does it do?” The first thing to note is that std::move() doesn’t actually move anything. It changes an expression from being … Read more
On the usefulness of const&&… (in general) The usefulness of the const&& qualifier on the member method is minimal at best. The object cannot be modified in the same manner as a && method would allow it to be modified; it is const after all (as noted, mutable does change this). So we will not … Read more
The solution you propose: void add(T value) { _impl.push_back(value); } Would require some adjustment, since this way you do always end up performing one copy of value, even if you pass an rvalue to add() (two copies if you pass an lvalue): since value is an lvalue, the compiler won’t automatically move from it when … Read more
Semantics Rust implements what is known as an Affine Type System: Affine types are a version of linear types imposing weaker constraints, corresponding to affine logic. An affine resource can only be used once, while a linear one must be used once. Types that are not Copy, and are thus moved, are Affine Types: you … Read more
There’s history, which is disappointing. But also a future that looks bright. When move semantics went into C++11, it was huge, controversial, and overwhelming. I wanted to be able to move strings into and out of stringstream. However the politics at the time demanded that the internal store did not have to be a basic_string<charT>. … Read more
Setting a raw pointer to null after moving it implies that the pointer represents ownership. However, lots of pointers are used to represent relationships. Moreover, for a long time it is recommended that ownership relations are represented differently than using a raw pointer. For example, the ownership relation you are referring to is represented by … Read more
My question: is this std::move really needed? My point is that compiler sees that this p_name is not used in the body of constructor, so, maybe, there is some rule to use move semantics for it by default? In general, when you want to turn an lvalue to an rvalue, then yes, you need a … Read more
First, std::move does not move, and std::forward does not forward. std::move is a cast to an rvalue reference. By convention, rvalue references are treated as “references you are permitted to move the data out of, as the caller promises they really don’t need that data anymore”. On the other side of the fence, rvalue references … 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
I was interested in your question because I was new to the topic and did some research. Let me present the results. First, your sigh. ::sighs:: C++0x was supposed to let me write less code, not more! what it is also supposed is to give you a better control over the code. And that it … Read more