unique/shared_ptr with custom operator= - c++

Question

I'm working with a polymorphic type (that is, I always interact with it through a pointer) that has methods "Destroy()" and "Clone()", and I would like to wrap it in a resource safe type.
Now, if "Destroy()" was all I had to worry about, then I could use unique_ptr with a custom deleter and it would be easy. But, this resource handle type is used as a member in another type that is otherwise copyable using default generated copy and assign operations. Ideally, I would like to customize the resource handle's copy constructor and assignment to invoke "Clone()", just like I already customize the resource handle's destructor to invoke "Destroy()". But looking through the docs on unique_ptr and shared_ptr, I don't see anything that would let me do that.
Did I miss something in the docs? Is there a ready-made std way to do this?
If not, should I extend unique_ptr and override the copy operations?
Alternatively, should I just write my own resource handle with all the usual pointer semantics from scratch?

Answer 1

You may create wrapper around std::unique_ptr
// To handle your cusstom Destroy
struct DestroyDeleter
{
void operator(Interface* o) {
object->Destroy();
delete object;
}
};
using InterfacePtr = std::unique_ptr<Interface, DestroyDeleter>;
// To handle the copy with clone:
class wrapper
{
public:
explicit wrapper(InterfacePtr o) : data(std::move(o)) {}
wrapper(const wrapper& rhs) : data(rhs.data->Clone()) {}
wrapper(wrapper&& rhs) = default;
wrapper& operator =(const wrapper& rhs) { data = rhs.data->Clone(); }
wrapper& operator =(wrapper&& rhs) = default;
const Interface* operator ->() const { return data.get(); }
Interface* operator ->() { return data.get(); }
const Interface& operator *() const { return data; }
Interface& operator *() { return *data; }
private:
InterfacePtr data;
};

Answer 2

One of the reasons for having a unique_ptr and a shared_ptr is that copying and juggling these pointers around is a cheap operation that does not involve copying the underlying object.
And that's why smart pointers do not implement any means for you to install your own operator=. As I understand your question, you want to wedge in a call to your custom Clone() and Destroy() methods, when a smart pointer gets copied.
Well, unique_ptr and shared_ptr implement their own operator= that does the right thing.
For starters whatever is being done by your Destroy() should really be done in your class's destructor. That's what a destructor is for. Then, your clone() method simply needs to clone its own object, and return a new unique_ptr, so, when you already have an existing unique_ptr or a shared_ptr, using it to invoke the clone() method clones the object and returns a smart pointer to the cloned object:
std::unique_ptr<myClass> p; // Or std::shared_ptr
// p is initialized, populated from there.
std::unique_ptr<myClass> new_p=p->clone();
Having a distinct Destroy() method that must be invoked before destroying an object is an invitation to spawn an endless parade of bugs. It's only a matter of time before you forget to call it when destroying a cloned object.
The best way to avoid creating and wasting time with bugs in your code is to make it logically impossible for them to happen. If something needs to be done in order to destroy an object, this needs to be done in the destructor. If something extra needs to be done in order to destroy an object that was cloned from another object, the object needs to have an internal flag that indicates that it's a cloned object, and have its destructor do the right thing, based on that.
Once that's done, it will become logically impossible for your code to screw up, by forgetting to do something to get rid of a cloned object. You can congratulate yourself for saving yourself, in the future, from wasting time searching for a bunch of bugs that will never be created, now. Your future self will thank your past self. Just use smart pointers as they were intended to be used, and have clone() give you a smart pointer right from the start.