📄 list.h

📁 游戏框架
💻 H
字号:
#include "stdafx.h"
#include <list>
#include <crtdbg.h>
using namespace std;

#define LISTTEMPLATE_LAST_ITEM				0
#define LISTTEMPLATE_FIRST_ITEM				1

/*
1.push	压入一元素
2.pop	弹出一元素
3.Get	返回一元素(根据位置,关键字,ID)
4.Remove删除一元素(根据位置,关键字,ID)
5.switch关换两个元素的位置
6.RemoveAll删除所有元素
7.GetSize返回列表长度
8.GetNext返回当前位置的后一个元素
9.GetPrev返回当前位置的前一个元素
*/
/**
 * LIST模板类
 * 下标从1开始的单向链表结构
 */
template <class TYPE, class ARG_TYPE=TYPE&>
class CListTemplate
{
protected:
	typedef struct tagElement{						// 内部结构
		ARG_TYPE		Key;
		TYPE			Object;
	}ELEMENTITEM;

	list<ELEMENTITEM>*				m_pItems;		// STD的LIST模板
	// Edit By Randy at 8-27
	typename list<ELEMENTITEM>::iterator		m_pIterator;	// 当前元素指针

public:
	CListTemplate(void);
	~CListTemplate(void);

	//操作函数
public:
	//元素压栈
	void Push(const TYPE Item, ARG_TYPE Key=NULL);
	//元素出栈
	TYPE Pop(void);
	//插入元素
	void Insert(const TYPE Item, INT_PTR Position = NULL, ARG_TYPE Key=NULL);
	//移除元素
	void Remove(INT_PTR Position);
	//根据KEY移除元素
	void RemoveBy(ARG_TYPE Key);
	//移除所有元素
	void RemoveAll(void);
	//返回元素
	TYPE Get(INT_PTR Position);
	//返回元素键
	ARG_TYPE GetKey(INT_PTR Position);
	//返回元素
	const TYPE operator[](INT_PTR Position);
	//根据KEY返回元素
	TYPE GetBy(ARG_TYPE Key);
	//根据KEY返回元素
	const TYPE operator[](ARG_TYPE Key);
	//重载=
	const CListTemplate<TYPE, ARG_TYPE>& operator=(const CListTemplate& List);
	//返回位置
	INT_PTR GetPosition(TYPE Object);
	//根据KEY返回位置
	INT_PTR GetPositionBy(ARG_TYPE Object);
	//交换元素
	void Switch(TYPE Object1, TYPE Object2);
	//交换位置
	void SwitchPosition(INT_PTR Position1, INT_PTR Position2);
	//枚举元素(从前向后枚举，减少每次从重头开始查找元素结点)
	TYPE Iterators(bool Reset=false);

	//信息函数
public:
	//是否空组
	bool IsEmpty() const;
	//获取数目
	INT_PTR GetCount() const;
};


//是否空组
template <class TYPE, class ARG_TYPE>
_inline CListTemplate<TYPE, ARG_TYPE>::CListTemplate()
{
	m_pItems = new list<ELEMENTITEM>;
}

//是否空组
template <class TYPE, class ARG_TYPE>
_inline CListTemplate<TYPE, ARG_TYPE>::~CListTemplate()
{
	delete m_pItems;
}

//是否空组
template <class TYPE, class ARG_TYPE>
_inline bool CListTemplate<TYPE, ARG_TYPE>::IsEmpty() const
{
	_ASSERT(this);
	return (m_pItems->size()==0);
}

//获取数目
template <class TYPE, class ARG_TYPE>
_inline INT_PTR CListTemplate<TYPE, ARG_TYPE>::GetCount() const
{
	_ASSERT(this);
	return m_pItems->size();
}

/**
* 将内容压栈
*/
template <class TYPE, class ARG_TYPE>
_inline void CListTemplate<TYPE, ARG_TYPE>::Push(const TYPE Item, ARG_TYPE Key){

	_ASSERT(this);

	ELEMENTITEM		eleItem;
	//ZeroMemory(&eleItem, sizeof(ELEMENTITEM));

	eleItem.Key = Key;
	eleItem.Object = Item;

	m_pItems->push_back(eleItem);
};

/**
* 将内容出栈
*/
template <class TYPE, class ARG_TYPE>
_inline TYPE CListTemplate<TYPE, ARG_TYPE>::Pop(){
	_ASSERT(this);

	if(m_pItems->size()>0){
		list<ELEMENTITEM>::iterator	iterEle = m_pItems->end();
		iterEle--;

		TYPE				eleItem = (*iterEle).Object;
		m_pItems->pop_back();

		return eleItem;
	}

	return NULL;
};

/**
* 指定位置之前插入
*/
template <class TYPE, class ARG_TYPE>
_inline void CListTemplate<TYPE, ARG_TYPE>::Insert(const TYPE Item, INT_PTR Position, ARG_TYPE Key){

	_ASSERT(this);
	_ASSERT(Position>=0);

	ELEMENTITEM		eleItem;

	ZeroMemory(&eleItem, sizeof(ELEMENTITEM));
	eleItem.Key = Key;
	eleItem.Object = Item;

	list<ELEMENTITEM>::iterator	iterEle = m_pItems->begin();
	for(INT_PTR iPos=1;iPos<Position && iPos<(INT_PTR)m_pItems->size()+1;iPos++)
		iterEle++;
	m_pItems->insert(iterEle, eleItem);
};

/**
* 删除元素
*/
template <class TYPE, class ARG_TYPE>
_inline void CListTemplate<TYPE, ARG_TYPE>::Remove(INT_PTR Position){
	_ASSERT(this);

	if(m_pItems->size()>0 && Position<=(INT_PTR)m_pItems->size()){
		list<ELEMENTITEM>::iterator	iterEle = m_pItems->begin();
		//Ele+=Position;
		for(INT_PTR iPos=1;iPos<Position && iPos<(INT_PTR)m_pItems->size();iPos++)
			iterEle++;

		m_pItems->erase(iterEle);
	}
};

/**
* 清空所有元素
*/
template <class TYPE, class ARG_TYPE>
_inline void CListTemplate<TYPE, ARG_TYPE>::RemoveAll(){
	_ASSERT(this);

	if(m_pItems->size()>0){
		m_pItems->clear();
	}
};

/**
* 移除指定的内容
*/
template <class TYPE, class ARG_TYPE>
_inline void CListTemplate<TYPE, ARG_TYPE>::RemoveBy(ARG_TYPE Key){
	_ASSERT(this);

	if(m_pItems->size()>0){
		INT_PTR		nIndex = 0;
		list<ELEMENTITEM>::iterator	iterEle, iterEleEnd;

		for(iterEle=m_pItems->begin(), iterEleEnd=m_pItems->end();iterEle!=iterEleEnd;iterEle++){
			nIndex++;
			if((*iterEle).Key == Key){
				break;
			}
		}

		Remove(nIndex);
	}
};

/**
* 返回指定位置的内容
*/
template <class TYPE, class ARG_TYPE>
_inline TYPE CListTemplate<TYPE, ARG_TYPE>::Get(INT_PTR Position){
	_ASSERT(this);
	_ASSERT(Position>0);

	if(m_pItems->size()>0 && Position<=(INT_PTR)m_pItems->size()){
		list<ELEMENTITEM>::iterator	iterEle = m_pItems->begin();
		for(INT_PTR iPos=1;iPos<Position && iPos<(INT_PTR)m_pItems->size()+1;iPos++)
			iterEle++;
		return (*iterEle).Object;
	}

	return NULL;
};

//返回元素键
template <class TYPE, class ARG_TYPE>
_inline ARG_TYPE CListTemplate<TYPE, ARG_TYPE>::GetKey(INT_PTR Position){
	if(m_pItems->size()>0 && Position<=(INT_PTR)m_pItems->size()){
		list<ELEMENTITEM>::iterator	iterEle = m_pItems->begin();
		for(INT_PTR iPos=1;iPos<Position && iPos<(INT_PTR)m_pItems->size()+1;iPos++)
			iterEle++;
		return (*iterEle).Key;
	}

	return NULL;
};

template <class TYPE, class ARG_TYPE>
_inline const TYPE CListTemplate<TYPE, ARG_TYPE>::operator[](INT_PTR Position){
	return Get(Position);
};

//重载=
template <class TYPE, class ARG_TYPE>
_inline const CListTemplate<TYPE, ARG_TYPE>& CListTemplate<TYPE, ARG_TYPE>::operator=(const CListTemplate& List){
	//清空列表
	RemoveAll();

	if(List.m_pItems->size()>0){
		list<ELEMENTITEM>::iterator	iterEle, iterEleEnd;
		for(iterEle=List.m_pItems->begin(), iterEleEnd = List.m_pItems->end();iterEle!=iterEleEnd;iterEle++){
			//m_pItems->push_back(List.m_pItems->
			Push((*iterEle).Object, (*iterEle).Key);
		}
	}

	return *this;
};

/**
* 根据ID返回指定内容
*/
template <class TYPE, class ARG_TYPE>
_inline TYPE CListTemplate<TYPE, ARG_TYPE>::GetBy(ARG_TYPE Key){
	_ASSERT(this);

	if(m_pItems->size()>0){
		list<ELEMENTITEM>::iterator	iterEle, iterEleEnd;
		for(iterEle=m_pItems->begin(), iterEleEnd = m_pItems->end();iterEle!=iterEleEnd;iterEle++){
			if((*iterEle).Key == Key){
				return (*iterEle).Object;
			}
		}
	}

	return NULL;
};

template <class TYPE, class ARG_TYPE>
_inline const TYPE CListTemplate<TYPE, ARG_TYPE>::operator[](ARG_TYPE Key){
	return GetBy(Key);
};

/**
* 交换两个项的位置
*/
template <class TYPE, class ARG_TYPE>
_inline void CListTemplate<TYPE, ARG_TYPE>::Switch(TYPE Object1, TYPE Object2){
	_ASSERT(this);

	if(m_pItems->size()>0){
		list<ELEMENTITEM>::iterator	Ele, EleEnd, Obj1, Obj2;
		bool						bFlag = false;
		EleEnd=m_pItems->end();
		// 查找第一个对象
		for(Ele=m_pItems->begin();Ele!=EleEnd;Ele++){
			if((*Ele).Object == Object1){
				Obj1 = Ele;
				bFlag = true;
				break;
			}
		}

		if(bFlag){
			bFlag = false;
			// 查找第二个对象
			for(Ele=m_pItems->begin();Ele!=EleEnd;Ele++){
				if((*Ele).Object == Object2){
					Obj2 = Ele;
					bFlag = true;
					break;
				}
			}
		}

		// 确定两个对象存在
		if(bFlag){
			ELEMENTITEM		eleTemp;

			eleTemp.Key = (*Obj1).Key;
			eleTemp.Object = (*Obj1).Object;
	
			(*Obj1).Key = (*Obj2).Key;
			(*Obj1).Object = (*Obj2).Object;

			(*Obj2).Key = eleTemp.Key;
			(*Obj2).Object = eleTemp.Object;
		}
	}
};

/**
* 交换两个项的位置
*/
template <class TYPE, class ARG_TYPE>
_inline void CListTemplate<TYPE, ARG_TYPE>::SwitchPosition(INT_PTR Position1, INT_PTR Position2){
	_ASSERT(this);

	TYPE eleItem1 = this->Get(Position1);
	TYPE eleItem2 = this->Get(Position2);

	if(eleItem1 != NULL && eleItem2 != NULL){
		this->Switch(eleItem1, eleItem2);
	}
};

/**
* 返回项目的位置
*/
template <class TYPE, class ARG_TYPE>
_inline INT_PTR CListTemplate<TYPE, ARG_TYPE>::GetPosition(TYPE Object){
	_ASSERT(this);

	if(m_pItems->size()>0){
		INT_PTR		nIndex = 0;
		list<ELEMENTITEM>::iterator	iterEle, iterEleEnd;
		for(iterEle=m_pItems->begin(), iterEleEnd = m_pItems->end();iterEle!=iterEleEnd;iterEle++){
			nIndex++;
			if((*iterEle).Object == Object){
				return nIndex;
			}
		}
	}

	return 0;
};

/**
* 返回键值的位置
*/
template <class TYPE, class ARG_TYPE>
_inline INT_PTR CListTemplate<TYPE, ARG_TYPE>::GetPositionBy(ARG_TYPE Key){
	_ASSERT(this);

	if(m_pItems->size()>0){
		INT_PTR		nIndex = 0;
		list<ELEMENTITEM>::iterator	iterEle, iterEleEnd;
		for(iterEle=m_pItems->begin(), iterEleEnd = m_pItems->end();iterEle!=iterEleEnd;iterEle++){
			nIndex++;
			if((*iterEle).Key == Key){
				return nIndex;
			}
		}
	}

	return 0;
};

//枚举元素(从前向后枚举，减少每次从重头开始查找元素结点)
template <class TYPE, class ARG_TYPE>
_inline TYPE CListTemplate<TYPE, ARG_TYPE>::Iterators(bool Reset){
	_ASSERT(this);

	// Edit By Randy at 8-27
	//测试发现由于list模板的Iterators方法，是使用一个static的iterator...来进行++的
	//如果一个对象包含两个list模板 ，两个list将会使用这一个iterator，将会导致
	//其中一个list..的iterator..指向的是另一个list的对象.
	//static list<ELEMENTITEM>::iterator		m_pIterator;	// 当前元素指针

	if(m_pItems->size()>0){
		list<ELEMENTITEM>::iterator		iterEleEnd = m_pItems->end();
		if(Reset){
			m_pIterator = m_pItems->begin();
		}
		else{
			++m_pIterator;
		}

		if(m_pIterator!=iterEleEnd)
			return m_pIterator->Object;
	}

	return NULL;
};
⌨️ 快捷键说明

复制代码 Ctrl + C
搜索代码 Ctrl + F
全屏模式 F11
切换主题 Ctrl + Shift + D
显示快捷键 ?
增大字号 Ctrl + =
减小字号 Ctrl + -