Copy constructor for a class with unique_ptr

Question

How do I implement a copy constructor for a class that has a unique_ptr member variable? I am only considering C++11.

Answer 1

Since the unique_ptr can not be shared, you need to either deep-copy its content or convert the unique_ptr to a shared_ptr.

class A
{
   std::unique_ptr< int > up_;

public:
   A( int i ) : up_( new int( i ) ) {}
   A( const A& a ) : up_( new int( *a.up_ ) ) {}
};

int main()
{
   A a( 42 );
   A b = a;
}

You can, as NPE mentioned, use a move-ctor instead of a copy-ctor but that would result in different semantics of your class. A move-ctor would need to make the member as moveable explicitly via std::move:

A( A&& a ) : up_( std::move( a.up_ ) ) {}

Having a complete set of the necessary operators also leads to

A& operator=( const A& a )
{
   up_.reset( new int( *a.up_ ) );
   return *this,
}

A& operator=( A&& a )
{
   up_ = std::move( a.up_ );
   return *this,
}

If you want to use your class in a std::vector, you basically have to decide if the vector shall be the unique owner of an object, in which case it would be sufficient to make the class moveable, but not copyable. If you leave out the copy-ctor and copy-assignment, the compiler will guide your way on how to use a std::vector with move-only types.

Answer 2

The usual case for one to have a unique_ptr in a class is to be able to use inheritance (otherwise a plain object would often do as well, see RAII). For this case, there is no appropriate answer in this thread up to now.

So, here is the starting point:

struct Base
{
    //some stuff
};

struct Derived : public Base
{
    //some stuff
};

struct Foo
{
    std::unique_ptr<Base> ptr;  //points to Derived or some other derived class
};

... and the goal is, as said, to make Foo copiable.

For this, one needs to do a deep copy of the contained pointer to ensure the derived class is copied correctly.

This can be accomplished by adding the following code:

struct Base
{
    //some stuff

    auto clone() const { return std::unique_ptr<Base>(clone_impl()); }
protected:
    virtual Base* clone_impl() const = 0;
};

struct Derived : public Base
{
    //some stuff

protected:
    virtual Derived* clone_impl() const override { return new Derived(*this); };                                                 
};

struct Foo
{
    std::unique_ptr<Base> ptr;  //points to Derived or some other derived class

    //rule of five
    ~Foo() = default;
    Foo(Foo const& other) : ptr(other.ptr->clone()) {}
    Foo(Foo && other) = default;
    Foo& operator=(Foo const& other) { ptr = other.ptr->clone(); return *this; }
    Foo& operator=(Foo && other) = default;
};

There are basically two things going on here:

• The first is the addition of a user-defined copy constructor of Foo, This is necessary, as the unique_ptr-member iself has no copy constructor. In the declared copy-constructor, a new unique_ptr is created, and the pointer is set to a copy of the original pointee.

• In case inheritance is involved, the copy of the original pointee must be done carefully. The reason is that doing a simple copy via std::unique_ptr<Base>(*ptr) in the code above would result in slicing, i.e., only the base component of the object gets copied, while the derived part is missing.

  To avoid this, the copy has to be done via the clone-pattern. The idea is to do the copy through a virtual function clone_impl() which returns a Base* in the base class. In the derived class, however, it is extended via covariance to return a Derived*, and this pointer points to a newly created copy of the derived class. The base class can then access this new object via the base class pointer Base*, wrap it into a unique_ptr, and return it via the actual clone() function which is called from the outside.

• Second, by declaring a user-defined copy-constructor as done above, the move constructor gets deleted by the corresponding C++ language rules. The declaration via Foo(Foo &&) = default is thus just to let the compiler know that the standard move constructor still applies.

Answer 3

Try this helper to create deep copies, and cope when the source unique_ptr is null.

    template< class T >
    std::unique_ptr<T> copy_unique(const std::unique_ptr<T>& source)
    {
        return source ? std::make_unique<T>(*source) : nullptr;
    }

Eg:

class My
{
    My( const My& rhs )
        : member( copy_unique(rhs.member) )
    {
    }

    // ... other methods

private:
    std::unique_ptr<SomeType> member;
};

Answer 4

Daniel Frey mention about copy solution,I would talk about how to move the unique_ptr

#include <memory>
class A
{
  public:
    A() : a_(new int(33)) {}

    A(A &&data) : a_(std::move(data.a_))
    {
    }

    A& operator=(A &&data)
    {
      a_ = std::move(data.a_);
      return *this;
    }

  private:
    std::unique_ptr<int> a_;
};

They are called move constructor and move assignment

you could use them like this

int main()
{
  A a;
  A b(std::move(a)); //this will call move constructor, transfer the resource of a to b

  A c;
  a = std::move(c); //this will call move assignment, transfer the resource of c to a

}

You need to wrap a and c by std::move because they have a name std::move is telling the compiler to transform the value to rvalue reference whatever the parameters are In technical sense, std::move is analogy to something like "std::rvalue"

After moving, the resource of the unique_ptr is transfer to another unique_ptr

There are many topics that document rvalue reference; this is a pretty easy one to begin with.

Edit :

The moved object shall remain valid but unspecified state.

C++ primer 5, ch13 also give a very good explanation about how to "move" the object

Answer 5

I suggest use make_unique

class A
{
   std::unique_ptr< int > up_;

public:
   A( int i ) : up_(std::make_unique<int>(i)) {}
   A( const A& a ) : up_(std::make_unique<int>(*a.up_)) {};

int main()
{
   A a( 42 );
   A b = a;
}

Answer 6

unique_ptr is not copyable, it is only moveable.

This will directly affect Test, which is, in your second, example also only moveable and not copyable.

In fact, it is good that you use unique_ptr which protects you from a big mistake.

For example, the main issue with your first code is that the pointer is never deleted which is really, really bad. Say, you would fix this by:

class Test
{
    int* ptr; // writing this in one line is meh, not sure if even standard C++

    Test() : ptr(new int(10)) {}
    ~Test() {delete ptr;}
};

int main()
{       
     Test o;
     Test t = o;
}

This is also bad. What happens, if you copy Test? There will be two classes that have a pointer that points to the same address.

When one Test is destroyed, it will also destroy the pointer. When your second Test is destroyed, it will try to remove the memory behind the pointer, as well. But it has already been deleted and we will get some bad memory access runtime error (or undefined behavior if we are unlucky).

So, the right way is to either implement copy constructor and copy assignment operator, so that the behavior is clear and we can create a copy.

unique_ptr is way ahead of us here. It has the semantic meaning: "I am unique, so you cannot just copy me." So, it prevents us from the mistake of now implementing the operators at hand.

You can define copy constructor and copy assignment operator for special behavior and your code will work. But you are, rightfully so (!), forced to do that.

The moral of the story: always use unique_ptr in these kind of situations.

Answer 7

As davdihigh mentioned in his answer. One uses a unique_ptr mostly because of inheritance. Thus, most of the time you have a std::unique_ptr<BaseType> instead of std::unique_ptr<ChildType> (where class ChildType : public BaseType {}). However, in order to create a std::unique_ptr<BaseType>, the ChildType is always directly involved at some point. You either pass a pointer to the ChildType, or a unique_ptr<ChildType> into the constructor.

There are situations where it's easier to switch the used unique_ptr class, than add a clone interface to all the Base- and ChildTypes that will be used at some point.

This enables one to write a wrapper around unique_ptr with a clone method (similar to the already existing custom deleter), like so:

template<typename T>
requires (std::has_virtual_destructor_v<T>)
class clonable_unique_ptr {

public: // Associated types
    using pointer = std::unique_ptr<T>::pointer;
    using element_type = std::unique_ptr<T>::element_type;
    using cloner_type = std::function<T*(const T*)>;

private:
    std::unique_ptr<T> ptr;
    cloner_type cloneFn = [](const T*) { return nullptr; };

    clonable_unique_ptr(T* rawPtr, cloner_type cloneFn)
        : ptr(rawPtr), cloneFn(cloneFn) {}

public:
    constexpr clonable_unique_ptr() noexcept {}
    constexpr clonable_unique_ptr(std::nullptr_t) noexcept {}

    /**
     * ctor creating a clonable_unique_ptr from a given rawPtr.
     * @attention The rawPtr must be of the type that it actually points to!
     *            Meaning: The ChildType
     */
    template<typename U>
    explicit clonable_unique_ptr(U* rawPtr) : ptr(rawPtr) {
        static_assert(std::derived_from<U, T>, "Types not compatible");
        static_assert(!std::is_abstract_v<U>, "Entrypoint ctors need to be given the actual type, not the base type!");
        static_assert(std::is_copy_constructible_v<U>, "Type needs to be copy constructible");
        cloneFn = [](const T* ptr) { return new U(*static_cast<const U*>(ptr)); };
    }

    /**
     * ctor creating a clonable_unique_ptr from a given unique_ptr<ChildType>.
     * @attention The ptr must be of the type that it actually points to!
     *            Meaning: The ChildType
     */
    template<typename U>
    clonable_unique_ptr(std::unique_ptr<U>&& o) {
        static_assert(std::derived_from<U, T>, "Types not compatible");
        static_assert(!std::is_abstract_v<U>, "Entrypoint ctors need to be given the actual type, not the base type!");
        static_assert(std::is_copy_constructible_v<U>, "Type needs to be copy constructible");
        cloneFn = [](const T* ptr) { return new U(*static_cast<const U*>(ptr)); };
        ptr = std::move(o);
    }

    /**
     * move ctor, moving from another instance of clonable_unique_ptr
     */
    clonable_unique_ptr(clonable_unique_ptr&& o)
        : ptr(std::move(o.ptr)), cloneFn(std::move(o.cloneFn)) {}

    /** move assignable */
    clonable_unique_ptr& operator=(clonable_unique_ptr&&) = default;


    // default unique_ptr interface with accessors
    T* get() const noexcept { return ptr.get(); }
    T* operator->() { return ptr.get(); }
    auto& operator*() const noexcept(noexcept(*std::declval<pointer>())) {
        return *ptr;
    }
    void reset() noexcept {
        ptr.reset();
        cloneFn = [](const T*) { return nullptr; };
    }
    void swap(clonable_unique_ptr& o) noexcept {
        ptr.swap(o.ptr);
        std::swap(cloneFn, o.cloneFn);
    }

    /**
     * Clone the instance of T contained in this pointer by using the copy ctor
     * of the ChildType that is contained in this ptr.
     */
    clonable_unique_ptr<T> clone() const {
        return clonable_unique_ptr(cloneFn(get()), cloneFn);
    }
};


template<typename T0, typename T1>
bool inline operator==(const clonable_unique_ptr<T0>& ptr0, const clonable_unique_ptr<T1>& ptr1) {
    return ptr0.get() == ptr1.get();
}
template<typename T0>
bool inline operator==(const clonable_unique_ptr<T0>& ptr0, std::nullptr_t) {
    return ptr0.get() == nullptr;
}

Like this, the responsibility of implementing the clone was pushed into the pointer and out of BaseClass/ChildClass. Some examples:

struct BaseClass {
    virtual void doStuff() = 0;
    virtual ~BaseClass() {}
};

struct ChildClass : public BaseClass {
    std::string value;
    ChildClass(std::string value) : value(value) {}
    void doStuff() override {
        std::cout << "doStuff: " << value << " " << this << std::endl;
    }
};

The clonable_unique_ptr can then be created using either a pointer to ChildType:

clonable_unique_ptr<BaseClass> fromPtr(new ChildClass("cake"));
clonable_unique_ptr<BaseClass> fromPtrClone = fromPtr.clone();
fromPtr->doStuff(); // two different instances
fromPtrClone->doStuff();

or from a std::unique_ptr<ChildType> for easier compatibility:

clonable_unique_ptr<BaseClass> fromUPtr = std::make_unique<ChildClass>("blub");
clonable_unique_ptr<BaseClass> fromUPtrClone = fromUPtr.clone();
fromUPtr->doStuff(); // two different instances
fromUPtrClone->doStuff();

Here is a link to Godbolt to toy with it. I didn't add custom deleter support to this wrapper yet, because I personally don't need it, but that should be trivial.