Ion Gaztañaga wrote:

Thomas Klimpel escribió:

...

But I have a question about Boost.Move: Because the problem Boost.Move addresses is so important, and Boost.Move wasn't around, my existent code uses efficient implementations of "swap" as a substitute. The documentation shows that Boost.Move can be used to implement an efficient swap. But what about the other direction? Can Boost.Move exploit an existent efficient swap?

Boost.Move calls user defined constructors to operate, so you can implement your move constructors using your efficient swap:

Type(BOOST_RV_REV(Type) t) : ...() //Empty construction { this->swap(t); }

I hope I can omit the empty construction, since some of my classes have many member variables. But on second thought, I should at least initialize the pointers to zero, to avoid undefined behavior in the destructor.

Ditto for move assignment:

Type & operator=(BOOST_RV_REV(Type) t) { Type tmp(boost::move(t)); this->swap(tmp); }

I hope I can omit the temporary, because two calls to swap are less efficient than a single call to swap. I can't find any second thought that forces me to create a temporary. Do I miss something? Regards, Thomas

Thomas Klimpel escribió:

...

Type(BOOST_RV_REV(Type) t) : ...() //Empty construction { this->swap(t); }

I hope I can omit the empty construction, since some of my classes have many member variables. But on second thought, I should at least initialize the pointers to zero, to avoid undefined behavior in the destructor.

This is a generic move constructor, if Type has a trivial destructor there is no need to mark the type as "moved", but as you say, if you have some pointers, you should prepare the swapped class destructor to avoid undefined behaviour.

...

Ditto for move assignment:

Type & operator=(BOOST_RV_REV(Type) t) { Type tmp(boost::move(t)); this->swap(tmp); }

I hope I can omit the temporary, because two calls to swap are less efficient than a single call to swap. I can't find any second thought that forces me to create a temporary. Do I miss something?

There is no reason if you know your type and you can put t in a destructible state. This is just a generic ("safe"?) move assignment operator. You could do: Type & operator=(BOOST_RV_REV(Type) t) { this->swap(t); } if semantically is ok for your Type. For some types (shared_ptr, containers...) a simple swap can lead to unexpected behavior because the programmer might not expect any value transference: shared_ptr<X> a(...), b(..); //Should b take ownership of a's resources? //That might be quite surprising. a = boost::move(b); Best, Ion