How to make deep a copy of shared_ptr?

Question

I have a simple class of Node tree MultNode. It's subclass of Node. _pRight and _pLeft are std::shared_ptr<Node> objects. Class Node is an abstract class. MultNode::DerFun() performs derivative function for multiplication Node.

I have to create temporary right and left Node(pTmpR and pTmpL) and I need use only smart pointers. I have no idea how to create deep copy of shrared_ptr.

void MultNode::DerFun() {
    auto pTmpR =  _pRight;
    auto pTmpL = _pLeft;
    _pRight->DerFun(); // sin(pi/4) * cos(pi/4);
    _pLeft->DerFun();  // der(sin(pi/4) * cos(pi/4));
    _pRight = std::make_shared<AddNode>(
        std::make_shared<MultNode>(_pRight, pTmpL),
        std::make_shared<MultNode>(pTmpR, _pLeft));
    _pLeft = std::make_shared<NumNode>(1);
}

Answer 1

deep copying a Derived by a Base pointer cannot be done by the compiler because it won't know what to copy at compile-time.

the solution is to make a virtual deepcopy function, which is responsible for making a deepcopy of this derived object, which will call deepcopy on all of its children to construct a true deepcopy, and since it is called on a pointer the correct function will be called at runtime.

#include <memory>

class Node {
public:
    virtual std::shared_ptr<Node> deepcopy() const = 0;
    virtual ~Node() = default;
};

class MultNode: public Node {
private:
    std::shared_ptr<Node> m_pleft;
    std::shared_ptr<Node> m_pright;
public:
    virtual std::shared_ptr<Node> deepcopy() const
    {
        return std::make_shared<MultNode>(m_pleft->deepcopy(), m_pright->deepcopy());
    }
    MultNode(std::shared_ptr<Node> pleft, std::shared_ptr<Node> pright) : 
        m_pleft(pleft), m_pright(pright) {};
};

Answer 2

There is no need to deep copy anything at all. You have shared pointers, use them to your advantage.

Here is a minimal system that can derive. Note it builds a DAG, not a tree. Everything is const, nothing is ever changed. The nodes are shared as much as possible.

#include <memory>

class Node;

using NodePtr = std::shared_ptr<const Node>;

using Number = double;

class Node
{
    public:
        virtual ~Node() = default;
        virtual NodePtr derive() const = 0;
};

class AddNode : public Node
{
    public:
        AddNode (const NodePtr& a, const NodePtr& b) : a(a), b(b) {}
    private:
        NodePtr a, b;
        NodePtr derive() const override 
        { 
            return std::make_shared<AddNode>(a->derive(), b->derive()); 
        }
};

class MultNode : public Node
{
    public:
        MultNode (const NodePtr& a, const NodePtr& b) : a(a), b(b) {}
    private:
        NodePtr a, b;
        NodePtr derive() const override
        {
            const auto l = std::make_shared<MultNode>(a, b->derive());
            const auto r = std::make_shared<MultNode>(a->derive(), b);
            return std::make_shared<AddNode>(l, r);
        }
};

class ConstNode : public Node
{
    public:
        ConstNode (Number v) : v(v) {}
    private:
        Number v;
        NodePtr derive() const override 
        { 
            return std::make_shared<ConstNode>(Number{0}); 
        }
};

class VarNode : public Node
{
    public:
        VarNode() {}
    private:
         NodePtr derive() const override 
         { 
             return std::make_shared<ConstNode>(Number{1}); 
         }
};

Caveats:

1. Not tested much
2. Only one variable supported (easy to change)
3. Many useful nodes missing, e.g. division, function composition, power, ... (easy to add)
4. No constant propagation or other means to simplify expressions (can be added as a separate method)