Copy constructor with pointers to own class

Question

Assume we have a class like this:

class C
{
public:
  C() {}
  virtual ~C() noexcept { if (c) { delete c; } }

protected:
  int a;
  float b;
  C* c;
}

How would you properly implement the copy and move constructors? Normally you would just invoke the copy constructor of the object that needs to be copied, but since it's the very same class, how would you handle this properly?

Answer 1

How would you properly implement the copy and move constructors?

Moving is easy: copy the victim's pointer to the target, then null the victim's to indicate that it no longer owns anything. And, of course, copy the other values.

For copying, you need to choose the semantics you want: unique ownership (in which case don't allow copying), shared ownership (in which case increment a reference count, and change the destructor to decrease it), deep copying (in which case allocate a new object, copying the old one), or something else.

Normally you would just invoke the copy constructor of the object that needs to be copied, but since it's the very same class, how would you handle this properly?

That's not necessarily a problem. If the chain of pointers ends somewhere, you'll just end up recursively copying everything on that chain; although it might be better to write a loop to avoid indefinite recursion. If it doesn't end, then it must be cyclic, so you'd need to check whether you get back to the object you started with.

Answer 2

Normally you would just invoke the copy constructor of the object that needs to be copied, but since it's the very same class, how would you handle this properly?

In the same recursive manner as you call the destructor of the same class. Since your destructor assumes the ownership of the pointed object, you must do a deep copy.

Moving is simple, just clear the pointer so it doesn't get deleted when the moved from object is destroyed. Just like any other owned raw pointer.

C(const C& other): a(other.a), b(other.b), c(other.c) {
    if(other.c)
        this->c = new C(*other.c);
}
C(C&& other): a(other.a), b(other.b), c(other.c) {
    other.c = nullptr;
}

Remember that the stack size will limit the recursion of your data structure. If you would leave memory management outside the class, then you could iterate the linked objects with a loop instead of recursion.

Answer 3

OK, the purpose of the question is unclear, and the way you'd write the copy and move operators would depend on the behaviour you wanted:

• do you want ownership of the subordinate C moved to the new class on move?

• do you want the subordinate C copied in the case of a copy? (deep copy)

• on copy, should the destination C share the subordinate C with the source C?

We could take a guess and assume that the answers are: yes, yes, no:

class C
{
public:

    // custom destructor == rule of 5

    C() {}

    C(C&& r) noexcept
    : _child { r._child }
    {
        r._child = nullptr;
    }

    C& operator=(C&& r) noexcept {
        swap(r);
        return *this;
    }

    C(const C& r)
    : _child { r._child ? r._child->clone() : nullptr }
    {
    }

    C& operator=(const C& r) {
        C tmp { r };
        swap(tmp);
        return *this;
    }

    // test for null is not necessary
    virtual ~C() noexcept { delete _child; }

public:
    void swap(C& r) noexcept {
        using std::swap;
        swap(_child, r._child);
    }

    // in case C is a polymorphic base class
    virtual C* clone() const {
        return new C { *this };
    }

private:
    C* _child = nullptr;
};

Answer 4

This is one of the reasons why smart pointers were invented. They are self managed, so the only thing you need to do is set them when you want, and they take care of releasing the memory when it is no longer used.

#include <memory>

class C
{
public:
  C() {}

protected:
  int a;
  float b;
  std::shared_ptr<C> c;
}

PS: I didn't ask, but cases in which you need a pointer to self are not that common; are you sure there is no workaround in your case?