struct TNode
{
   TAtrributes m_Atrributes;

   TNode* m_pLeftChild;
   TNode* m_pRightChild;

   TNode* m_pParent;
};

struct A {
  B subordinate;
};

shared_ptr<A> pa = make_shared<A>();
shared_ptr<B> pb(&pa->subordinate, pa);
pa.reset(); // но pb, а через него и весь объект A, продолжает жить!
pb.reset(); // теперь А умрёт и по-человечески убъёт B своим деструктором

struct Node {
  Node *up, *lt, *rt;
  unsigned refcount;
};

bool is_alive(Node const* node) {
  assert(node);
  return node->up || node->refcount;
}

void delete_subtree(Node* node) {
  if (!node) return;
  delete_subtree(node->left);
  delete_subtree(node->right);
  delete node;
}

void try_delete(Node* node) {
  if (node && !is_alive(node)) delete_subtree(node);
}

void incref_impl(Node* node, int delta) {
  if (delta == 0) return;
  Node* top = nullptr;
  // бежим вверх по дереву
  while(node) {
    top = node;
    node->refcount += delta;
    node = node->up;
  }
  // если корень дерева отсох, удаляем его
  if (delta < 0) try_delete(node);
}

void intrusive_addref(Node* node) { incref_impl(node, +1); }
void intrusive_decref(Node* node) { decref_impl(node, -1); }

void cut_left(Node* node) {
  assert(node && node->left);
  Node* left = node->left;
  // разрываем связь
  left->up = nullptr;
  node->left = nullptr;
  // и отнимаем ставшие неродными счётчики
  incref_impl(node, -left->refcount);
  try_delete(left);
}

void attach_left(Node* node, Node* left) {
  assert(node && !node->left);
  assert(left && !left->up);
  // добавляем счётчики
  incref_impl(node, +left->refcount);
  // и создаём связь
  left->up = node;
  node->left = left;
}

bool is_alive(Node* node) {
  return node->refcount || (node->left && is_alive(node->left)) || (node->right && is_alive(node->right));
}

    enum { NONE = -1 };

    typedef int NODE;                   //!< Узел дерева
    typedef int ATTR;                   //!< Атрибут узла

    class Document
    {
        ... ...

        struct NodeInfo
        {
            NAMEREF name;               // Ссылка на имя
            NODE next,                  // Следующий
                 prev,                  // Предыдущий
                 parent,                // Родительский узел
                 child;                 // Первый дочерний узел
            ATTR attr;                  // Первый атрибут узла
            VALREF value;               // Ссылка на значение

            NodeInfo()
                : name(NONE)
                , next(NONE), prev(NONE)
                , parent(NONE), child(NONE)
                , attr(NONE), value(NONE) {}
        };

        typedef std::vector<NodeInfo> TNodes;
        // ------------------------------------------------------------------
        NODE m_RootNode;                // Корневой узел
        NODE m_NodeFreeList;            // Список удаленных узлов

        TNodes m_InfoNode;              // Свойства узлов

        ... ...
    };

    class inode
    {
    public:
        inode();
        inode(Document* pdoc, NODE n);
        inode(const inode& n);

        LPCTSTR getName() const;
        LPCTSTR getValue() const;

        void setValue(LPCTSTR valN);
        void setValue(LPCTSTR valN, size_t length);

        iattr getAttrs() const;
        iattr getAttr(LPCTSTR name) const;

        inode getChild() const;
        inode getChild(LPCTSTR name) const;
        inode getParent() const;
        inode getNext() const;
        inode getPrev() const;

        const inode& operator++();
        bool end() const;

        NODE id() const;

        //! Добавить дочерний узел после <prev>
        inode addNode(LPCWSTR name, NODE prev);

        //! Задать значение атрибута
        iattr setAttr(LPCWSTR name, LPCWSTR val);

    protected:
        Document* m_pdoc;
        NODE m_id;
    };

SVZ>>Предлагаю "ход конём". Заменить указатели на индексы в массиве.

// ==========================================================================
// Создать узел
dom::NODE dom::Document::makeNode(LPCTSTR name)
{
    dom::NODE nodeN = m_NodeFreeList;
    if ( nodeN < 0 )
    {
        nodeN = static_cast<dom::NODE>(m_InfoNode.size());
        m_InfoNode.push_back( NodeInfo() );
    }
    else
    {
        m_NodeFreeList = m_InfoNode[nodeN].next;
        m_InfoNode[nodeN] = NodeInfo();
    }

    NAMEREF nref = makeNodeName(name);
    m_InfoNode[nodeN].name = nref;

    return nodeN;
}

__>struct TNode
__>{
__>   TAtrributes m_Atrributes;

__>   TNode* m_pLeftChild;
__>   TNode* m_pRightChild;

__>   TNode* m_pParent;
__>};
__>

struct do_nothing
{
  template <class T>
  void operator ()(T*) { }; // do nothing
};
 
template <class T>
  using non_owning_ptr = unique_ptr<T, do_nothing>;

It is intended as a near drop-in replacement for raw pointer types, with the advantage that, as a vocabulary type, it indicates its intended use without need for detailed analysis by code readers.

MX> Это просто удобный способ отметить где у тебя, скорее всего, ошибка в программе.

__>p.s. T4r4sB, это же вы, по-моему, недавно говорили, что raw-ptr устарели

struct node_offsets {
    int parent_offset;
    enum { left_child_offset = 1 };
    int right_child_offset;
};

struct node_offsets {
    int parent_offset;
    enum { left_child_offset = 1 };
    int right_child_offset;
    
    node_offsets* get_patent() { return  get_by_offset( parent_offaset ); }
    node_offsets* get_left() { return  this + left_child_offset; }
    node_offsets* get_right() { return  get_by_offset( right_child_offset ); }
private:
    node_offsets* get_by_offset( int offset ) { return offset != 0 ? this + offset : 0; }    

};