Appropriate type of non-static field that automatic copy= by value and support polymorphism

Question

Suppose that I have a class B.
B is a container of a single field C c;.
C is designed to be a base class. It is the super class of C1,C2, etc.

class C{
    public: int dummy=3;
    public: virtual void print(){ std::cout<<"I am C"<<std::endl; }
};
class C2: public C{
    public: virtual void print(){ std::cout<<"I am C2"<<std::endl; }
};
class B{
    public: ??? c;  //C or C* or std::unique_ptr or ....
};  

Question

Which is a suitable data type of a light-weight field c that :-

(#1) c can also hold an instance of a derive class e.g. C2.
(#2) The field c is automatically copied by value when calling B::operator=() or default B's copy constructor, so no custom functions are required.
(#3) c is automatically deleted when B is deleted, so no B's custom destructor is required.

Roughly speaking, here is what I expect :-

int main(){
    B b1;
    b1.c = C2();    //(#1)
    B b2=b1;        //  b2.c should be another copy of b.c 
    b2.c.dummy = 3;   //(#2) b.c should not be effected    
    //(#3) both b1.c and b2.c are deleted, no memory leak 
}

It is very useful for prototyping (prototype-pattern), where I want to copy many objects and customize each of them with high flexibility and minimum human-error (because no need to maintain either copy-constructor or operator=()).

My poor solutions

Version 1 (C*)

#include <iostream>
class C{
    public: virtual void print(){ std::cout<<"I am C"<<std::endl; }
};
class C2: public C{
    public: virtual void print(){ std::cout<<"I am C2"<<std::endl; }
};
class B{
    public: C* c;
};    
int main(){
    B b1;
    b1.c = new C2(); 
    B b2=b1;   
}

The approach does not meet the requirement :-

• violate (#2): In B b2=b;, b.c is shallow copy. I want deep copy.
• violate (#3): I have to delete b.c manually, or add such statement in B's destructor.

Version 2 (std::unique_ptr)

class B{
    public: std::unique_ptr<C> c=nullptr;
};    
int main(){
    B b1;
    b1.c = std::make_unique<C2>();
    B b2=b1;
}

This is not compilable because default B::operator=() no longer work.
I have to manually code B::operator=().
I don't want to code it manually, because it is (human-)error-prone. (violate (#2))

Version 3 (new customize class)

Encapsulate C inside a custom class that do exactly what I want.

Here is a draft :-

template<class T> CrazyCopy{
    T* t;
    // write some custom operator=, custom constructor, custom destructor
};
class B{
    public: CrazyCopy<C> c;
};

I think it is overkill. (?)

Answer 1

I think if you want that particular combination of behavior, you do need a custom pointer. Try this.

template<class T>
class CrazyCopy {

    public:

        CrazyCopy<T>() : t_(nullptr) {}

        CrazyCopy<T>(T* const t) : t_(t) {}

        CrazyCopy<T>(const CrazyCopy<T>& t) : t_(new T(*t.t_)) {}

        CrazyCopy<T>(CrazyCopy&& t) : t_(t.t_) {
            t.t_ = nullptr;
        }

        ~CrazyCopy<T>() {
            delete t_;
        }

        CrazyCopy<T>& operator=(const CrazyCopy<T>& t) {
            delete t_;
            t_ = new T(*t.t_);
        }

        CrazyCopy<T>& operator=(CrazyCopy<T>&& t) {
            t_   = t.t_;
            t.t_ = nullptr;
        }

        T& operator*() const {
            return *t_;
        }

        T* Get() const {
            return t_;
        }

        void Reset(T* const t) {
            delete t_;
            t_ = t;
        }

    protected:

        T* t_;

};

Answer 2

The custom class is the way to go. We do have to take care of object slicing, so some type erasure is needed for the copy operation. A first stab at it might look like this:

template <class T>
struct copy_ptr {

    copy_ptr() = default;

    copy_ptr(copy_ptr const &orig)
    : _ptr{orig._cpy(*orig._ptr)}
    , _cpy{orig._cpy} { }

    template <class U>
    copy_ptr(std::unique_ptr<U> ptr)
    : _ptr{std::move(ptr)}
    , _cpy{[](T const &obj) -> std::unique_ptr<T> {
        return std::make_unique<U>(static_cast<U const &>(obj));
    }} { }

    // Assignment and move operations left as an exercise :)

private:
    std::unique_ptr<T> _ptr;

    using Copier = std::unique_ptr<T> (*)(T const &);
    Copier _cpy = [](T const &){ return std::unique_ptr<T>{}; };
};

When initializing a copy_ptr<T> with a unique_ptr<U>, with U derived from T, we generate and store the cloning function, which is then used to perform copies.

See it live on Coliru