C++ list iterator

완성

#include<iostream>
using namespace std;
 
template<typename T>
class Node
{
public:
    T     Data;  
    Node* Prev;// 이전노드
    Node<T>* NextNode;; // 본인 선언 내부에 있을시 <T>생략 가능
public:
    Node(const T& Data, Node* Prev, Node<T>* NextNode)
        :Data(Data)
        ,Prev(Prev)
        ,NextNode(NextNode)
    {
 
    }
};
 
template<typename T>
class CList
{
private:
    Node<T>* HeadNode; //포인터가 가르키는 자료형이 무엇인지 알려주는 <T>가 있어야함
    Node<T>* TailNode; // 꼬리 맨마지막 노드
    int  count;
public:
    void PushBack(const T& Data);
    void PushFornt(const T& Data);
    class iterator;
    iterator begin();
    iterator end();
    iterator erase(iterator& iter);
    iterator insert(const iterator& iter, const T& Data);
public:
    CList();
    ~CList();
 
    class iterator
    {
    private:
        CList<T>*  _list;
        Node<T>*  _node; // null인 경우, end iterator로 간주
        bool    v;
    public:
        iterator()
            :_list(nullptr)
            ,_node(nullptr)
            , v(false)
        {}
 
        iterator(CList<T>* _list, Node<T>* _node)
            :_list(_list)
            ,_node(_node)
            ,v(false)
        {
        if (_node != nullptr && nullptr != _list)
        {
            v = true;
        }
        }
    public:
        T& operator *()
        {
            if (v == false)
            {
                assert(nullptr);
            }
            return _node->Data;
        }
        ~iterator()
        {
 
        }
        bool operator ==(const iterator& _other)
        {
            if (_list == _other._list && _node == _other._node)
            {
                return true;
            }
            return false;
        }
 
        bool operator !=(const iterator& _other)
        {
            return !(*this == _other);
        }
 
        iterator& operator ++()
        {
            //end에서 ++한 경우
            if (_node == nullptr || !v)
            {
                assert(nullptr);
            }
 
            _node = _node->NextNode;
 
            return *this;
        }
        const iterator operator ++(int)
        {
            iterator copyier = (*this);
 
            ++(*this);
 
            return copyier;
        }
        iterator& operator --()
        {
 
        }
        iterator operator --(int)
        {
 
        }
        friend class CList;
    };
};
 
template<typename T>
 void CList<T>::PushBack(const T & Data)
{
     //입력된 데이터를 저장할 노드를 동적할당 함
     Node<T>* NewNode = new Node<T>(Data, TailNode,nullptr);
    
     if (count == 0)
     {
         HeadNode = NewNode;
 
         TailNode = NewNode; //데이터가 하나일시 처음과 마지막데이터가 같음
     }
     else 
     {
         //데이터가 1개 이상에서 입력된 경우
         //현재 가장 마지막 데이터(tail)를 저장하고 있는 노드가
         //새로 생성된 노드를 서로 가리키게 한다.
         TailNode->NextNode = NewNode;
        // NewNode->Prev = TailNode; 위에 선언에 있음
        
         //List 가 마지막 노드의 주소값을 새로 입력된 노드로 갱신한ㄷ.
         TailNode = NewNode;
     }
     count++;
}
 
 template<typename T>
  void CList<T>::PushFornt(const T & Data)
 {
      //새로 생성된 노도의 다음을 현재 헤드노드의 주소값으로 채움
      Node<T>* pNewNode = new Node<T>(Data,nullptr,HeadNode);
      if (count == 0) {
          HeadNode = pNewNode;
          TailNode = pNewNode;
      }
      else {
         //현재 헤드노드의 이전노드 주소값을 새로 생선된 노드의 주소로 채움
          HeadNode->Prev = pNewNode;
        
          // 위에 선언에 있음
        //  pNewNode->NextNode = HeadNode; 
 
          //리스트가 새로 생성된 노드의 주소를 새로운 헤드주소로 갱신한다.
          HeadNode = pNewNode;
 
      }
      count++;
      
 }
 
  template<typename T>
  inline typename CList<T>::iterator CList<T>::begin()
  {
      return iterator(this,HeadNode);
  }
 
  template<typename T>
  inline typename CList<T>::iterator CList<T>::end()
  {
      return iterator(this,nullptr);
  }
 
  template<typename T>
  inline typename CList<T>::iterator CList<T>::erase(iterator& iter)
  {
      if (HeadNode == iter._node)
      {
          HeadNode = iter._node->NextNode;
     }
      else
      {
          iter._node->Prev->NextNode = iter._node->NextNode;
          
          iter._node->NextNode->Prev = iter._node->Prev;
      }
 
      iter.v = false;
      count--;
      return iterator(this,iter._node->NextNode);
  }
 
  template<typename T>
  inline typename CList<T>::iterator CList<T>::insert(const iterator& iter, const T & Data)
  {
      
      //리스트에 추가되는 데이터를 저장 할 Node생성
      Node<T>* pNew = new Node<T>(Data, nullptr, nullptr);
      // iterator 가 가리키는 노드가 헤드노드인 경우
      if (end() == iter )
      {
          assert(nullptr);
      }
      if (iter._node == HeadNode)
      {
          iter._node->Prev = pNew;
          pNew->NextNode = iter._node;
 
          HeadNode = pNew;
      }
      else{
          //iterator 가 가리키고 있는 노도의 이전으로 가서
          // 다음 노드 주소 파트 새로 생성된 노드로 지정
          iter._node->Prev->NextNode = pNew; // 
          pNew->Prev = iter._node->Prev;
 
      // iterator  가 가리키고 있는 노드의 이전을 새로운 노드로 지정
      //새로운 노드의 pNext를 iterator 가 가리키고 있는 노드로 지정
      iter._node->Prev = pNew;
      pNew->NextNode = iter._node;
      }
     count++;
      return iterator(this,pNew);
  }
 
template<typename T>
 CList<T>::CList()
    :HeadNode(nullptr)
    ,TailNode(nullptr)
    ,count(0) 
{
}
 
template<typename T>
 CList<T>::~CList()
{
     Node<T>* DeletNode = HeadNode;
 
     for (int i = 0; i < count; i++)
     {
        // cout << HeadNode->Data<<"\n";
         HeadNode = HeadNode->NextNode;
     }
    
     while (DeletNode)
     {
         Node<T>* pNext = DeletNode->NextNode;
         delete(DeletNode);
         DeletNode = pNext;
     }
    
    
    
 }
 
 

출처 : https://www.youtube.com/c/AssortRockGameAcademy