There's still a bunch of people around who just love bringing tons of setters(), getters() and resetters() to type interfaces. It's certainly welcomed by the type users, but it brings hell to their maintainers, mainly due to the growing number of unmanageable execution paths that ultimately transform the implementation into spaghetti code. I call that types just containers as they are no longer able to effectively preserve their invariants.

Ideally, a very limited number of (re)initialization paths should exist within a type. Two of them are obvious: the constructor and the 'operator ='. Both are responsible for establishing object's invariants. The third one, not so obvious, is just a plane swap() function that can help us to get rid of all the setters() and resetters() by reusing the well established path of the constructor as demonstrates the example blow:

Please note that the whole point of the 'swap' technique is to preserve object's identity (address), otherwise we could just wrap the type to a std:unique_ptr or use another type of handle, and completely recreate the object each time a state update is needed.

It's also worth mentioning that the overhead of swap() is usually pretty insignificant, especially with the move semantics that C++11 brings.