Get a std::list::iterator from std::reference_wrapper - c++

Question

I'm coding a Fibonacci heap data structure (https://en.wikipedia.org/wiki/Fibonacci_heap) in C++.
This data structure consists of several heaps, with roots connected in a doubly-linked list. Each node has a doubly-linked list of its children. A whole heap has a doubly-linked list of leaf nodes, to support fast pruning. (CLRS 19-3.b)
My implementation of Node is:
struct Node {
using Iterator = std::list<std::unique_ptr<Node>>::iterator;
using LeafIterator = std::list<std::reference_wrapper<std::unique_ptr<Node>>>::iterator;
Iterator parent;
std::list<std::unique_ptr<Node>> child_list;
T key;
bool mark = false;
bool is_leaf = false;
LeafIterator leaf_iterator;
Node(const T& key) : key {key} {}
};
My implementation of FibonacciHeap is:
using Iterator = std::list<std::unique_ptr<Node>>::iterator;
using LeafIterator = std::list<std::reference_wrapper<std::unique_ptr<Node>>>::iterator;
std::list<std::unique_ptr<Node>> NIL;
std::list<std::unique_ptr<Node>> root_list;
std::list<std::reference_wrapper<std::unique_ptr<Node>>> leaf_list;
Iterator min_element;
I used std::list<std::reference_wrapper<std::unique_ptr<Node>>> for leaf_list, instead of std::list<Node*>, because the memory of leaf nodes are solely owned by their parents, and I don't want double-delete crash.
The problem arises when I attempt to delete a leaf node. I can access a leaf node to delete by leaf_list.begin(), but I cannot erase it from its parent's child_list.
There are two possible workarounds I thought:
Perform a linear scan from parent's child_list to get a std::list<std::unique_ptr<Node>>::iterator that matches the given leaf. This is a linear scan, so slow.
Ditch leaf_list and maintain two pointers as member variables of Node that contains prev_leaf and next_leaf to emulate doubly linked list. I don't like this because it would make Nodes more bloaty.
...can't think else for now
What would be the best way to get std::list<std::unique_ptr<Node>>::iterator from std::reference_wrapper in this case?

Answer 1

Using a std::list<Node*> would not cause any double deletes, as long as you don't manually delete nodes, and let the actual unique_ptr pointers in child_list members handle that. You would just need to be careful to avoid using a dangling pointer after a Node has been destroyed. But this way still doesn't give a good way to quickly remove a Node* from the appropriate child_list.
Instead, you could maybe use std::list<Iterator> leaf_list;. This is relatively safe since inserts and erases on a std::list do not invalidate any iterators (except of course iterators to erased elements).
Though since you still have an invariant to follow, that the iterators in leaf_list belong to the appropriate child_list, it would be good to help code follow it. Depending on the intended usage and generality of the class, that might mean just putting notes in comments within or just before the struct Node definition. Or it might mean making Node a proper class with private members and a safer public interface - I might consider creating custom iterators using boost::iterator_adaptor to allow iteration over the leaf nodes without as much danger of breaking the invariant. If you don't expect much reuse, but then find it would be useful again in more contexts or projects, you could of course change these sorts of decisions later (unless too much code gets written using the raw way).