Question

I’m wondering if there is a way to implement copy constructors and assignment operators such that only a small modification is needed when these are redefined for a class.

For example, consider a class as such:

class Foo {
private:
    int* mInt_ptr;
    /* many other member variables
       of different types that aren't
       pointers */
public:
    Foo();
    Foo(const Foo&);
    Foo& operator=(const Foo&);
    ~Foo();
};

Now, in order to deal with the pointer mInt_ptr I would need to handle it appropriately in the copy constructor and assignment operator. However, the rest of the member variables are safe to do a shallow copy of. Is there a way to do this automatically?

Once a class becomes large it may become tedious and unwieldy to explicitly write out the operations to copy the non-pointer member variables, so I’m wondering if there is a way to write, say, a copy constructor such as:

Foo::Foo(const Foo& tocopy)
{
    mInt_ptr = new int(*tocopy.mInt_ptr);
    /* Do shallow copy here somehow? */
}

rather than the explicit form of:

Foo::Foo(const Foo& tocopy)
{
    mInt_ptr = new int(*tocopy.mInt_ptr);
    mVar1 = tocopy.mVar1;
    mVar2 = tocopy.mVar2;
    ...
    ...
    mVarN = tocopy.mVarN;
}

Answer 1

Generally, don’t use raw pointers, for exactly the reason that you’re now fighting with. Instead, use a suitable smart pointer, and use copy-swap assignment:

class Foo
{
     int a;
     Zip z;
     std::string name;
     value_ptr<Bar> p;

public:
     Foo(Foo const &) = default;

     Foo & operator=(Foo rhs)
     {
         rhs.swap(*this);
         return *this;
     }

     void swap(Foo & rhs)
     {
         using std::swap;
         swap(a, rhs.a);
         swap(z, rhs.z);
         swap(name, rhs.name);
         swap(p, rhs.p);
     }
};

namespace std { template <> void swap<Foo>(Foo & a, Foo & b) { a.swap(b); } }

The value_ptr could be a full-blown implementation, or something simple such as this:

template <typename T>    // suitable for small children,
class value_ptr          // but not polymorphic base classes.
{
    T * ptr;

public:
    constexpr value_ptr() : ptr(nullptr) { }
    value_ptr(T * p) noexcept : ptr(p) { }
    value_ptr(value_ptr const & rhs) : ptr(::new T(*rhs.ptr)) { }
    ~value_ptr() { delete ptr; }
    value_ptr & operator=(value_ptr rhs) { rhs.swap(*this); return *this; }
    void swap(value_ptr & rhs) { std::swap(ptr, rhs.ptr); }

    T & operator*() { return *ptr; }
    T * operator->() { return ptr; }
};