CList의 내부 구조 이해

CList 를 사용하기 위해서는
#include <afxtempl.h> 이걸 해주어야 한다.

그리고
CList<CPoint, CPoint&> testt;
이런식으로 선언해서 사용한다.

CList는 템플릿을 사용해서 구현된다.

CList를 이해하기 위해서는 링크드리스트의 이해가 필요하며, 레퍼런스가 무엇인지도 알아야 한다.

저 아래에 보면, CNode*& 가 있는데, 이것은 CNode*를 레퍼런스르 넘겨서 값을 받아오기 위해

사용한다. 원래는 CNode**로 넘겨야 하는데, 레퍼런스로 넘기면 알기도 쉽고 사용하기도 쉬우니까

CNode*&가 사용된다.

 

 

#ifndef _LIST_H_

#define _LIST_H_

 

template <class TYPE, class ARG_TYPE>

class CList

{

public:

             struct CNode

             {

                           CNode* pNext;

                           CNode* pPrev;

                           TYPE data;

             };

 

public:                // Construction

             CList();

             virtual ~CList();

 

public:                // Operations

             CNode* AddHead( ARG_TYPE newElement );

             CNode* AddTail( ARG_TYPE newElement );

 

             void AddHead( CList* pNewList );              // 과제

             void AddTail( CList* pNewList );                // 과제

            

             TYPE GetNext( CNode*& pList );

             TYPE GetPrev( CNode*& pList );

            

             TYPE GetHead() const;

             TYPE GetTail() const;

            

             int  GetCount() { return m_nCount; }

 

 

             CNode* GetHeadPosition() { return m_pNodeHead; }

             CNode* GetTailPosition() { return m_pNodeTail; }

 

             void   RemoveAll();

             void   RemoveHead();

             void   RemoveTail();

 

public:                // Implementation

             CNode* m_pNodeHead;

             CNode* m_pNodeTail;

             int      m_nCount;

};

 

template <class TYPE, class ARG_TYPE>

CList<TYPE, ARG_TYPE>::CList()

{

             m_pNodeHead = m_pNodeTail = NULL;

             m_nCount = 0;

}

 

template <class TYPE, class ARG_TYPE>

CList<TYPE, ARG_TYPE>::~CList()

{

             RemoveAll();

}

 

template <class TYPE, class ARG_TYPE>

CList<TYPE, ARG_TYPE>::CNode* CList<TYPE, ARG_TYPE>::AddHead( ARG_TYPE newElement )

{

             CNode* pNewNode = new CNode;

             pNewNode->data = newElement;

 

             if( m_pNodeHead != NULL )

             {

                           m_pNodeHead->pPrev = pNewNode;

                           pNewNode->pNext = m_pNodeHead;

                           pNewNode->pPrev = NULL;

             }

             else

             {

                           m_pNodeTail = pNewNode;

                           pNewNode->pPrev = pNewNode->pNext = NULL;

             }

 

             m_pNodeHead = pNewNode;

             m_nCount++;

 

             return pNewNode;

}

 

template <class TYPE, class ARG_TYPE>

CList<TYPE, ARG_TYPE>::CNode* CList<TYPE, ARG_TYPE>::AddTail( ARG_TYPE newElement )

{

             CNode* pNewNode = new CNode;

             pNewNode->data = newElement;

 

             if( m_pNodeTail != NULL )

             {

                           m_pNodeTail->pNext = pNewNode;

                           pNewNode->pPrev = m_pNodeTail;

                           pNewNode->pNext = NULL;

             }

             else // m_pNodeTail == NULL

             {

                           m_pNodeHead = pNewNode;

                           pNewNode->pPrev = pNewNode->pNext = NULL;

             }

 

             m_pNodeTail = pNewNode;

             m_nCount++;

 

             return pNewNode;

}

 

template <class TYPE, class ARG_TYPE>

void CList<TYPE, ARG_TYPE>::AddHead( CList* pNewList )

{

             CNode* pNodeNew = pNewList->GetTailPosition();

             while( pNodeNew )

             {

                           AddHead( pNewList->GetPrev( pNodeNew ) );

             }

}

 

template <class TYPE, class ARG_TYPE>

void CList<TYPE, ARG_TYPE>::AddTail( CList* pNewList )

{

             CNode* pNodeNew = pNewList->GetHeadPosition();

             while( pNodeNew )

             {

                           AddTail( pNewList->GetNext( pNodeNew ) );

             }

}

 

 

template <class TYPE, class ARG_TYPE>

TYPE CList<TYPE, ARG_TYPE>::GetNext( CNode*& pList )

{

             TYPE val;

             val = pList->data;

             pList = pList->pNext;

            

             return val;

}

 

template <class TYPE, class ARG_TYPE>

TYPE CList<TYPE, ARG_TYPE>::GetPrev( CNode*& pList )

{

             TYPE val;

             val = pList->data;

             pList = pList->pPrev;

            

             return val;

}

 

template <class TYPE, class ARG_TYPE>

TYPE CList<TYPE, ARG_TYPE>::GetHead() const

{

             if( m_pNodeHead )

             {

                           return m_pNodeHead->data;

             }

 

             ASSERT( FALSE );            // 잘못된 함수 호출

}

 

template <class TYPE, class ARG_TYPE>

TYPE CList<TYPE, ARG_TYPE>::GetTail() const

{

             if( m_pNodeTail )

             {

                           return m_pNodeTail->data;

             }

 

             ASSERT( FALSE );            // 잘못된 함수 호출

}

 

template <class TYPE, class ARG_TYPE>

void CList<TYPE, ARG_TYPE>::RemoveAll()

{

             CNode* pNode = m_pNodeHead;

 

             while( pNode )

             {

                           CNode* pNodeDel = pNode;

                           pNode = pNode->pNext;

                           delete pNodeDel;

             }

 

             m_pNodeHead = m_pNodeTail = NULL;

             m_nCount = 0;

}

 

template <class TYPE, class ARG_TYPE>

void CList<TYPE, ARG_TYPE>::RemoveHead()

{

             if( !m_pNodeHead )

             {

                           ASSERT( FALSE );

             }

 

             if( m_pNodeHead->pNext )

             {

                           CNode* pNode = m_pNodeHead->pNext;

                           pNode->pPrev = NULL;

                           delete m_pNodeHead;

                           m_pNodeHead = pNode;

             }

             else      

             {

                           delete m_pNodeHead;

                           m_pNodeHead = m_pNodeTail = NULL;

             }

 

             m_nCount--;

}

 

template <class TYPE, class ARG_TYPE>

void CList<TYPE, ARG_TYPE>::RemoveTail()

{

             if( !m_pNodeTail )

             {

                           ASSERT( FALSE );

             }

 

             if( m_pNodeTail->pPrev )

             {

                           CNode* pNode = m_pNodeTail->pPrev;

                           pNode->pNext = NULL;

                           delete m_pNodeTail;

                           m_pNodeTail = pNode;

             }

             else

             {

                           delete m_pNodeTail;

                           m_pNodeHead = m_pNodeTail = NULL;

             }

 

             m_nCount--;

}

 

#endif