📄 ew_list.h
字号:
/*--------------------------------------------------------------------------
EW_list.h - 单、双向链表容器及迭代器头文件
本程序是FishGUI软件的一部分
版权所有 (C) 2003,2004 王咏武
http://www.contextfree.net/wangyw/
----------------------------------------------------------------------------
作者对 FishGUI 软件及其所有源代码授权如下：
允许任何个人、组织、机构、企业无偿获得、修改、使用、重新发布 FishGUI 软
件及其源代码，或按照有偿或者无偿的方式发行基于 FishGUI 源代码的全部或部
分内容开发的软件产品，——但行使以上权利时，须遵守以下约定：
1、重新发布 FishGUI 软件及其源代码时，不得隐去软件及其源代码中原有的版
权信息和开发者标识。
2、发行基于 FishGUI 源代码的全部或部分内容开发的软件产品时，必须在产品
的显著位置标明以下字样：
【本产品的一部分功能是基于王咏武在 FishGUI 软件中的工作完成的】
3、在正式出版物中引用 FishGUI 的文档、源代码或注释内容的，应注明软件的
原作者为王咏武。
--------------------------------------------------------------------------*/
/*! \addtogroup Utility
* @{
*/
/*! \file
* \brief 单、双向链表容器及迭代器头文件
*
*/
#ifndef _EW_LIST_H_
#define _EW_LIST_H_
//##ModelId=3FD88507008D
/*! \brief 单向链表的节点结构
*
* \param ITEM 节点中保存的对象类型，该节点中只保存ITEM对象的指针，并且不负责该对象的释放
*/
template <class ITEM>
struct EW_SList_Node
{
//##ModelId=3FD8850802FC
/*! \brief 缺省构造函数
*
* \ref EW_SList_Node::m_pItem和\ref EW_SList_Node::m_pNext都被设置为\ref NULL
*/
EW_SList_Node() : m_pItem(NULL), m_pNext(NULL) {}
//##ModelId=40925B4D03DE
/*! \brief 转换构造函数
*
* \ref EW_SList_Node::m_pNext被设置为\ref NULL
* \param pItem 需转换的对象指针
*/
EW_SList_Node(ITEM * const pItem) : m_pItem(pItem), m_pNext(NULL) {}
//##ModelId=3FD8850802CA
ITEM * m_pItem; /*!< 指向该结点保存的对象，\ref EW_SList_Node类不负责该对象的释放 */
//##ModelId=3FD8850802E1
EW_SList_Node * m_pNext; /*!< 指向直接后继结点的指针 */
};
//##ModelId=3FD885060262
/*! \brief 双向链表的节点结构
*
* \param ITEM 节点中保存的对象类型，该节点中只保存ITEM对象的指针，并且不负责该对象的释放
*/
template <class ITEM>
struct EW_BList_Node
{
//##ModelId=3FD8850701E2
/*! \brief 缺省构造函数
*
* \ref EW_BList_Node::m_pItem、\ref EW_BList_Node::m_pPrev和\ref EW_BList_Node::m_pNext都被设置为\ref NULL
*/
EW_BList_Node() : m_pItem(NULL), m_pPrev(NULL), m_pNext(NULL) {}
//##ModelId=40925B4C02E2
/*! \brief 转换构造函数
*
* \ref EW_BList_Node::m_pPrev和\ref EW_BList_Node::m_pNext被设置为\ref NULL
* \param pItem 需转换的对象指针
*/
EW_BList_Node(ITEM * const pItem) : m_pItem(pItem), m_pPrev(NULL), m_pNext(NULL) {}
//##ModelId=3FD88507018A
ITEM * m_pItem; /*!< 指向该结点保存的对象，\ref EW_SList_Node类不负责该对象的释放 */
//##ModelId=3FD8850701A7
EW_BList_Node * m_pPrev; /*!< 指向直接前趋结点的指针 */
//##ModelId=3FD8850701C7
EW_BList_Node * m_pNext; /*!< 指向直接后继结点的指针 */
};
//##ModelId=3FD8850602EF
/*! \brief 正向迭代器类
*
* \param NODE 节点类型
* \param ITEM 节点中保存的对象类型
*/
template <class NODE, class ITEM>
class EW_ForwardIterator
{
public:
//##ModelId=3FD8850702DC
/*! \brief 正向迭代器类的缺省构造函数 */
EW_ForwardIterator() : m_pNode(NULL) {}
//##ModelId=3FD8850702E6
/*! \brief 正向迭代器类的转换构造函数
*
* 把节点类指针转换成正向迭代器
*/
EW_ForwardIterator(NODE * const pNode) : m_pNode(pNode) {}
//##ModelId=3FD8850702F0
/*! \brief 重载*运算符函数
*
* 把正向迭代器转换成其指向的对象的引用
* \return 正向迭代器转换成其指向的对象的引用
*/
ITEM & operator*() const { return * (m_pNode->m_pItem); }
//##ModelId=3FD8850702FA
/*! \brief 重载->运算符函数
*
* 把正向迭代器转换成其指向的对象的指针
* \return 正向迭代器转换成其指向的对象的指针
*/
ITEM * operator->() const { return m_pNode->m_pItem; }
//##ModelId=3FD885070304
/*! \brief 重载转换运算符函数
*
* 把正向迭代器转换成其指向的对象的指针
* \return 正向迭代器转换成其指向的对象的指针
*/
operator ITEM *() const { return m_pNode->m_pItem; }
//##ModelId=3FD885070305
/*! \brief 是否遍历结束
*
* \return true 已经遍历结束
* false 还未遍历结束
*/
bool IsDone() const { return ! m_pNode; }
//##ModelId=3FD88507030E
/*! \brief 重载前置++运算符函数
*
* 正向迭代器指向下一个对象
* \return 改变后的正向迭代器
*/
EW_ForwardIterator & operator++()
{
if (m_pNode)
m_pNode = m_pNode->m_pNext;
return * this;
}
//##ModelId=3FD885070318
/*! \brief 重载后置++运算符函数
*
* 正向迭代器指向下一个对象
* \return 改变前的正向迭代器
*/
const EW_ForwardIterator operator++(int)
{
EW_ForwardIterator tmp = * this;
if (m_pNode) m_pNode = m_pNode->m_pNext;
return tmp;
}
//##ModelId=3FD885070323
/*! \brief 重载==运算符函数
*
* 比较两个正向迭代器是否指向同一个对象
* \return true 指向同一个对象
* false 指向不同的对象
*/
bool operator==(const EW_ForwardIterator & i) const { return m_pNode == i.m_pNode; }
//##ModelId=3FD885070336
/*! \brief 重载!=运算符函数
*
* 比较两个正向迭代器是否指向不同的对象
* \return true 指向不同的对象
* false 指向同一个对象
*/
bool operator!=(const EW_ForwardIterator & i) const { return m_pNode != i.m_pNode; }
//##ModelId=3FD88507034A
/*! \brief 重载==运算符函数
*
* 比较正向迭代器是否指向某个特定的对象
* \return true 指向该对象
* false 不是指向该对象
*/
bool operator==(ITEM * const p) const { return m_pNode->m_pItem == p; }
//##ModelId=3FD88507035E
/*! \brief 重载!=运算符函数
*
* 比较正向迭代器是否不指向某个特定的对象
* \return true 不是指向该对象
* false 指向该对象
*/
bool operator!=(ITEM * const p) const { return m_pNode->m_pItem != p; }
protected:
//##ModelId=3FD8850702C9
NODE * m_pNode; /*!< \brief 正向迭代器当前指向的节点 */
};
//##ModelId=3FD88506029F
/*! \brief 反向迭代器类
*
* \param ITEM 节点中保存的对象类型
*/
template <class ITEM>
class EW_BackIterator
{
public:
//##ModelId=3FD8850602D2
/*! \brief 反向迭代器能使用的双向链表节点类型 */
typedef EW_BList_Node<ITEM> node;
//##ModelId=3FD885070228
/*! \brief 反向迭代器类的缺省构造函数 */
EW_BackIterator() : m_pNode(NULL) {}
//##ModelId=3FD885070232
/*! \brief 反向迭代器类的转换构造函数
*
* 把节点类指针转换成反向迭代器
*/
EW_BackIterator(node * const pNode) : m_pNode(pNode) {}
//##ModelId=3FD88507023C
/*! \brief 重载*运算符函数
*
* 把反向迭代器转换成其指向的对象的引用
* \return 反向迭代器转换成其指向的对象的引用
*/
ITEM & operator*() const { return * (m_pNode->m_pItem); }
//##ModelId=3FD885070246
/*! \brief 重载->运算符函数
*
* 把反向迭代器转换成其指向的对象的指针
* \return 反向迭代器转换成其指向的对象的指针
*/
ITEM * operator->() const { return m_pNode->m_pItem; }
//##ModelId=3FD885070250
/*! \brief 重载转换运算符函数
*
* 把反向迭代器转换成其指向的对象的指针
* \return 反向迭代器转换成其指向的对象的指针
*/
operator ITEM *() const { return m_pNode->m_pItem; }
//##ModelId=3FD885070251
/*! \brief 是否遍历结束
*
* \return true 已经遍历结束
* false 还未遍历结束
*/
bool IsDone() const { return ! m_pNode; }
//##ModelId=3FD88507025A
/*! \brief 重载前置++运算符函数
*
* 反向迭代器指向前一个对象
* \return 改变后的反向迭代器
*/
EW_BackIterator & operator++()
{
if (m_pNode)
m_pNode = m_pNode->m_pPrev;
return * this;
}
//##ModelId=3FD885070264
/*! \brief 重载后置++运算符函数
*
* 反向迭代器指向前一个对象
* \return 改变前的反向迭代器
*/
const EW_BackIterator operator++(int)
{
EW_BackIterator tmp = * this;
if (m_pNode) m_pNode = m_pNode->m_pPrev;
return tmp;
}
//##ModelId=3FD88507026F
/*! \brief 重载==运算符函数
*
* 比较两个反向迭代器是否指向同一个对象
* \return true 指向同一个对象
* false 指向不同的对象
*/
bool operator==(const EW_BackIterator & i) const { return m_pNode == i.m_pNode; }
//##ModelId=3FD885070282
/*! \brief 重载!=运算符函数
*
* 比较两个反向迭代器是否指向不同的对象
* \return true 指向不同的对象
* false 指向同一个对象
*/
bool operator!=(const EW_BackIterator & i) const { return m_pNode != i.m_pNode; }
//##ModelId=3FD885070296
/*! \brief 重载==运算符函数
*
* 比较反向迭代器是否指向某个特定的对象
* \return true 指向该对象
* false 不是指向该对象
*/
bool operator==(ITEM * const p) const { return m_pNode->m_pItem == p; }
//##ModelId=3FD8850702A1
/*! \brief 重载!=运算符函数
*
* 比较反向迭代器是否不指向某个特定的对象
* \return true 不是指向该对象
* false 指向该对象
*/
bool operator!=(ITEM * const p) const { return m_pNode->m_pItem != p; }
private:
//##ModelId=3FD885070215
node * m_pNode; /*!< \brief 反向迭代器当前指向的节点 */
};
//##ModelId=3FD885060385
/*! \brief 循环迭代器类
*
* 循环迭代器从起始对象指针开始遍历，直到容器中的最后一个对象，
* 然后再从容器中的第一个元素开始遍历，直到起始对象（不包括起始对象）
* \param ITEM 节点中保存的对象类型
*/
template <class ITEM>
class EW_LoopIterator
{
public:
//##ModelId=3FD88508011B
/*! \brief 循环迭代器的构造函数
*
* \param pFirst 指向容器中的第一个对象的指针
* \param pStart 指向循环遍历的起始对象的指针
*/
EW_LoopIterator(EW_BList_Node<ITEM> * const pFirst, ITEM * const pStart)
: m_pFirst(pFirst), m_pStart(pStart), m_IsDone(false)
{
m_pNode = m_pFirst;
while (m_pNode && m_pNode->m_pItem != m_pStart) m_pNode = m_pNode->m_pNext;
if (! m_pNode)
m_IsDone = true;
else
{
m_pNode = m_pNode->m_pNext;
if (! m_pNode)
m_pNode = m_pFirst;
}
}
//##ModelId=3FD88508012F
/*! \brief 重载*运算符函数
*
* 把循环迭代器转换成其指向的对象的引用
* \return 循环迭代器转换成其指向的对象的引用
*/
ITEM & operator*() const { return * (m_pNode->m_pItem); }
//##ModelId=3FD885080139
/*! \brief 重载->运算符函数
*
* 把循环迭代器转换成其指向的对象的指针
* \return 循环向迭代器转换成其指向的对象的指针
*/
ITEM * operator->() const { return m_pNode->m_pItem; }
//##ModelId=3FD885080143
/*! \brief 重载转换运算符函数
*
* 把循环迭代器转换成其指向的对象的指针
* \return 循环迭代器转换成其指向的对象的指针
*/
operator ITEM *() const { return m_pNode->m_pItem; }
//##ModelId=3FD88508014D
/*! \brief 是否遍历结束，即循环遍历完容器中的所有对象
*
* \return true 已经遍历结束
* false 还未遍历结束
*/
bool IsDone() const { return m_IsDone; }
//##ModelId=3FD88508014E
/*! \brief 重载前置++运算符函数
*
* 循环迭代器指向下一个对象
* \return 改变后的循环迭代器
*/
EW_LoopIterator & operator++()
{
if (! m_IsDone)
{
m_pNode = m_pNode->m_pNext;
if (! m_pNode)
m_pNode = m_pFirst;
if ((m_pNode->m_pNext && m_pNode->m_pNext->m_pItem == m_pStart) ||
(! m_pNode->m_pNext && m_pFirst->m_pItem == m_pStart))
m_IsDone = true;
}
return * this;
}
//##ModelId=3FD885080157
/*! \brief 重载后置++运算符函数
*
* 循环迭代器指向下一个对象
* \return 改变前的循环迭代器
*/
const EW_LoopIterator operator++(int)
{
EW_LoopIterator tmp = * this;
if (! m_IsDone)
{
m_pNode = m_pNode->m_pNext;
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -