D>template<typename T>
D>class Tree
D>{
D>public:

D>  using ptr_type = std::shared_ptr<T>;
D>  using weakptr_type = std::weak_ptr<T>;

D>Tree(ptr_type parent)
D>{
D>  SetParent(parent);
D>}

D>ptr_type Parent()
D>{
D>  return m_parent.lock();
D>} 

D>void SetParent(ptr_type parent) 
D>{
D>  m_parent = parent;

D>}

D>private:

D>weakptr_type m_parent;
D>std::vector<ptr_type> m_children;
D>};
D>

template <typename T>
class Tree : public std::enable_shared_from_this<Tree<T>>
{
public:

  template<typename...Args>
  explicit Tree(Args&&...args) : m_data(std::forward<Args>(args)...) {}
  
  std::shared_ptr<Tree> AddChild(const std::shared_ptr<Tree>& child)
  {
    using base = std::enable_shared_from_this<Tree>;
    m_children.push_back(child);
    child->m_parent = base::shared_from_this();
    return child;
  }

  template<typename...Args>
  std::shared_ptr<Tree> CreateChild(Args&&...args)
  {
    return AddChild(std::make_shared<Tree>(std::forward<Args>(args)...));
  }

private:
  T m_data;
  std::weak_ptr<Tree> m_parent;
  std::vector<std::shared_ptr<Tree>> m_children;
};

int main()
{
  const auto root_ptr = std::make_shared<Tree<int>>();
  root_ptr->CreateChild(1)->CreateChild(11)->CreateChild(111);
  root_ptr->CreateChild(2)->CreateChild(21)->CreateChild(211);
}

//...
private:
    Child();
friend shered_ptr<Child>(); // или как-то так, не помню.

//...
template <typename Child> void Parent::Creare ()
{
    shared_prt<Child> child = make_shared<Child>();
    if (child)
    { //..
    }
}