class Node
{
    vector< shared_ptr<Node> > _children;
    weak_ptr<Node> _parent;
    ...
};

class Node
{
    struct NodeData
    {
        vector<Node> _children;
        weak_ptr<NodeData> _parent;
    };
    shared_ptr<NodeData> _data;
};

class RefCounted
{
    struct Counter
    {
        int strong_counter;
        int weak_counter;
        RefCounted* ptr;
    }
private:
    Counter *c;
}
template <class T> strong_ptr
{
    T* ptr; // указывает на сам объект
}
template <class T> weak_ptr
{
    RefCounted::Counter* ptr; // указывает на блок счетчиков
}
class Node: public RefCounted
{
    vector< strong_ptr<Node> > children;
    weak_ptr<Node> parent;
}

const A* const ptr = new A();
delete ptr;

void MyTree::AddChild( shared_ptr<MyTree> newChild )
{
    if( newChild->HasParent() ) {
        newChild->Detach();
    }
    children.push_back( newChild );
    newChild->setParent( this );
}

struct node_t
{
    unsigned refcount_;
    node_t* parent_;
    std::vector<node_t*> children_;
    int data_;

    node_t(int data)
    {
        data_ = data;
        refcount_ = 1;
        parent_ = 0;
    }

    node_t* acquire()
    {
        ++refcount_;
        return this;
    }

    void release()
    {
        if (--refcount_ == 0)
            delete this;
    }

    void add_child(node_t* n)
    {
        assert(n->parent_ == 0);
        n->acquire();
        n->parent_ = this;
        children_.push_back(n);
    }

    ~node_t()
    {
        assert(parent_ == 0);
        for (auto child = children_.begin(); child != children_.end(); ++child)
        {
            assert((*child)->parent_ == this);
            (*child)->parent_ = 0;
            (*child)->release();
        }
    }
};

int main()
{
    node_t* n1 = new node_t (1);
    node_t* n2 = new node_t (2);
    node_t* n3 = new node_t (3);
    // собираем дерево
    n1->add_child(n2);
    n2->release();
    n1->add_child(n3);
    n3->release();

    // захватываем один из подузлов
    node_t* n4 = n2->acquire();

    // удаляем дерево, но наш узел пока живёт
    n1->release();

    // отпускаем наш подузел
    n4->release();
}

struct node_t
{
    node_t* parent_;
    node_t* next_;
    node_t* children_;

struct node_t : intrusive_list_member<> // или какой нибудь intrusive_set если надо по детям поиск прикручивать
{
    node_t* parent_;
    intrusive_list<node_t> children_;

S>class Node
S>{
S>    vector< shared_ptr<Node> > _children;
S>    weak_ptr<Node> _parent;
S>    ...
S>};
S>

class node: public ref_counted
{
  node* parent;
  collection< handle<node> > children;
};