实现对映射进行迭代的类迭代器

如何创建一个类迭代器，在不导致内存泄漏的情况下对通用映射节点进行迭代？我的映射有一个名为"pair"的类，它是泛型的，有一个值和一个键。还有一个名为node的类，它包含一对指向下一个节点和前一个节点的指针。映射本身包含头节点。以及地图大小。。这个代码工作正常，我的问题是它有内存泄漏。因为迭代器是一个类（我们被要求实现为一个类，而不仅仅是一个节点），并且它包含一个指向具有对的node的指针。我们不能通过删除节点来删除对，只要我们想使用迭代器析构函数cause来完全删除对和导致映射中元素丢失的节点。你能给我一些建议吗？如何在没有内存泄漏的情况下正确实现？非常重要的是：map函数end（）应该返回一个不是map元素之一的随机值（这就是我将其设置为NULL的原因）

template <class KeyType, class ValueType, class CompareFunction = std::less<KeyType> >
class MtmMap {
public:
    class Pair {
    public:
        Pair(const KeyType& key, const ValueType& value)
            : first(key), second(value) {}
        Pair()
            : first(NULL), second(NULL) {}
        ~Pair(){}
        const KeyType first;
        ValueType second;
        bool operator==(const Pair& pair)const{
            if(pair.first==this->first&&pair.second==this->second){
                return true;
            }
            return false;
        }
        bool operator!=(const Pair& pair)const{
            if(this==pair){
                return false;
            }
            return true;
        }
        Pair& operator=(const Pair& pair){
            if(this==&pair){
                return *this;
            }
            this->first=pair.first;
            this->second=pair.second;
            return *this;
        }
        Pair& operator=(ValueType val){
            this->second=val;
            return *this;
        }
        const KeyType& getFirst(){
            KeyType* keyPointer=&first;
            return (first);
        }
        ValueType getSecond(){
            ValueType* valPoiner= &second;
            return (valPoiner);
        }
    };
    class Node {
        public:
            Pair* element;
            //int plc;
            Node* next;
            Node* before;
            Node() :element(), next(NULL),before(NULL){}
            Node(const Node& copyNode) :
                    element(new Pair(*(copyNode.element))), next(
                            copyNode.next) ,before(copyNode.before){
            }
            Node& operator++(){
                if(this->next){
                return(this->next);
                }
                Node* node=new Node;
                node->next=NULL;
                node->element=NULL;
                //node->first=NULL;
                return(node);
            }
            Node operator++(int n){
                Node result=*this;
                ++this;
                return result;
            }
            Node& operator--(){
                return(this->before);
            }
            bool operator==(const Node& node)const{
                if(node.before==this->before&&node.element==this->element&&node.next==this->next){
                    return true;
                }
                return false;
            }
            bool operator!=(const Node& node)const{
            if(this==node){
                return false;
            }
            return true;
            }
            Node& operator=(const Node& node){
                if(this==&node){
                    return *this;
                }
                this->before=node.before;
                this->element=node.element;
                this->next=node.next;
                return *this;
            }
            }
        };
    class iterator{
    public:
        Node* p;
        iterator():p(){}
        iterator(const iterator& it):p(it.p){}
        ~iterator(){
        }
        iterator& operator++(){
        this->p=this->p->next;
        if(this->p){
            return *this;
        }
        this->p=NULL;
        return *this;
        }
        iterator operator++(int n){
            iterator result=*this;
            ++*this;
            return result;
        }
        iterator& operator=(const iterator& it){
            if(this==&it){
                return *this;
            }
            this->p=it.p;
            return *this;
        }
        bool operator==(const iterator& iterator)const{
            if(this->p==iterator.p){
                return true;
            }
            return false;
        }
        bool operator!=(const iterator& iterator)const{
            if(this->p!=iterator.p){
                return true;
            }
            return false;
        }
        const Pair& operator*(){
            if(*this==end()){
                throw MapElementNotFoundException();
            }
            return *p->element;
        }
        iterator& begin(){
            while(p->before!=NULL){
                p--;
            }
            return *this;
        }
        iterator& end(){
            iterator* it=new iterator();
            it->p=NULL;
            return *it;
        }

    };
    int mapSize;
    Node* head;
    iterator iter;
    ValueType initializer;
    CompareFunction compareFunc;
    MtmMap(ValueType val):mapSize(0),head(),iter(),initializer(val){}