Using new operator for copy an object to heap without knowing its type

Question

I have a doubt, the function below can receive an object of type A or something derived type.

A *copyToHeap(A &obj) {
    A *ptr=new A(obj);
    return ptr;
}

If we call it like this:

//B inherits from A
B bObj;
B *hPtr=copyToHeap(bObj);

The object pointed by hPtr is actually of type A or B? Is safe doing this?

Answer 1

when you do the below in your code:

A* ptr = new A(obj);

you'll always get an A instance. obj will be treated as an A and a new A will get created based on the "A part" of obj.

The better approach is as an earlier reply indicated, add a virtual MakeCopy method to the base class and implement it for the derived classes.

virtual A* MakeCopy();

This method is implemented by making a copy of the object for which its called. It then gets implemented in the derived classes so if you have an A pointer which is actually a B object you'll get a true B copy and avoid the "slicing" which is occurring in your example.

Answer 2

The returned object is of type pointer to A, which means the object pointed to by hPtr is of type A. It's not safe since calling methods or members exclusive to B will cause a crash or undefined behavior. You're probably looking for the factory pattern.

Answer 3

A safe way is to provide a virtual clone method

#include <memory>

class Base
{
public:
    virtual std::unique_ptr<Base> Clone() = 0;
};

class Derived : public Base
{
public:
    Derived(int i) : i_(i)
    {

    }

    std::unique_ptr<Base> Clone()
    {
        return std::unique_ptr<Derived>(new Derived(i_));
    }

private:
    int i_;
};


std::unique_ptr<Base> copyToHeap(std::unique_ptr<Base> obj) 
{
    return obj->Clone();
}

Answer 4

It is not safe, it is incorrect, and the compiler should give you some diagnostics. Did you try to compile with g++ -Wall if using GCC?