Deep Clone for a unique_ptr which point to a base class

Question

The problem is: How can I do the deep clone for a unique_ptr which point to a base class, and the base class has some virtual functions.

The detail code:

class QueryRewrite {
public:
     QueryRewrite(bool wasRes, ReturnMeta rmeta, const KillZone &kill_zone, 
                  AbstractQueryExecutor *const executor)
         : rmeta(rmeta), kill_zone(kill_zone),
           executor(std::unique_ptr<AbstractQueryExecutor>(executor)) {}
     QueryRewrite(const QueryRewrite &other_qr)
         : rmeta(other_qr.rmeta), kill_zone(other_qr.kill_zone),
           executor(other_qr.executor.get()) {}
     QueryRewrite(){}
     QueryRewrite(QueryRewrite &&other_qr) : rmeta(other_qr.rmeta),
           executor(std::move(other_qr.executor)) {}
     const ReturnMeta rmeta;
     const KillZone kill_zone;
     std::unique_ptr<AbstractQueryExecutor> executor;
};

In the copy constructor

QueryRewrite(const QueryRewrite &other_qr)
         : rmeta(other_qr.rmeta), kill_zone(other_qr.kill_zone),
           executor(other_qr.executor.get()) {}

executor(other_qr.executor.get()) is just a shallow copy to the executor, if I want to do the deep copy, how to change the code?

And executor is a unique_ptr which point to an instance of AbstractQueryExecutor, the AbstractQueryExecutor is a base class which has some virtual functions, so if I change the code to executor(new AbstractQueryExecutor(other_qr.executor.get())), it will say something like:

 error: cannot allocate an object of abstract type ‘AbstractQueryExecutor’
 note:   because the following virtual functions are pure within ‘AbstractQueryExecutor’:

C introduced `unique_ptr` and all the foundation required to make them work!? Cool! — StoryTeller - Unslander Monica, Feb 22 '17 at 08:31
http://stackoverflow.com/questions/16030081/copy-constructor-for-a-class-with-unique-ptr — Rishi, Feb 22 '17 at 08:34
The `unique_ptr` is not really related to the issue. This is the classic problem of polymorphic copy, normally solved by a virtual `clone()` member function. — Angew is no longer proud of SO, Feb 22 '17 at 08:35
`executor(other_qr.executor.get())` isn't a shallow copy, it creates a pointer that two different `unique_ptr`s both think they uniquely own. Which isn't good. — Yakk - Adam Nevraumont, Feb 22 '17 at 08:58

score 0 · Answer 1 · answered Feb 22 '17 at 08:54

Write a value_ptr which inherits from a unique_ptr, but on copy construct/assigning invokes unique_ptr<T> T::clone() const on non-null T* to clone.

The use that.

template<class T, class D=std::default_delete<T>>
struct value_ptr:std::unique_ptr<T,D>{
  using base=std::unique_ptr<T,D>;
  using base::base;
  value_ptr()=default;
  value_ptr(value_ptr&&)=default;
  value_ptr& operator=(value_ptr&&)=default;
  value_ptr(base&& o):base(std::move(o)){}
  value_ptr(value_ptr const&o):
    value_ptr( o?value_ptr(o->clone()):value_ptr() )
  {}
  value_ptr& operator=(value_ptr const&o){
    value_ptr tmp(o);
    *this=std::move(tmp);
    return *this;
  }
};

That should do it. Code not tested.

The abstract base needs to have a virtual std::unique_ptr<AbstractBase> clone()const added, and derived need to implement, for the above to work.

Also follow the rule of zero; once you have a value ptr, you can =default or sometimes skip the copy/move ctors/assigns of enclosing classes.

As an aside, consider copy on write instead of deep copy.

Deep Clone for a unique_ptr which point to a base class

1 Answers1