练习系列 - 4、异质链表
/*!
\file List.h
\author 刘宝
\version 1.0
\date 2010/12/3
\brief 异质链表List及其节点接口IListNode的声明
*/
#ifndef LIST
#define LIST
class IListNode;
class List;
class ListPrivate;
/*! List中iterate遍历函数使用的回调函数 */
typedef bool (*callback)(IListNode *, int index, void * param);
/*!
\class IListNode
\brief List链表使用的节点接口类
*/
class IListNode
{
/*! 声明List为友元，便于List访问process函数和私有指针 */
friend class List;
public:
IListNode(): owner(0), prev(0), next(0) {}
IListNode(const IListNode &node): owner(0), prev(0), next(0) {}
IListNode &operator=(const IListNode &node);
virtual ~IListNode(); //! 析构函数
protected:
/*!
protected类型纯虚处理函数，子类实现后用于处理相应子类
\param param 处理函数参数，将由List::processAll(void *param) const传入
\return 若处理成功返回true，否则返回false
*/
virtual bool process(void *param) = 0;
private:
List *owner;
IListNode *prev;
IListNode *next;
};
/*!
\class List
\brief 异质链表类，使用继承自IListNode的节点，无法被复制
本异质链表类具有以下特点：
- 支持基本的插入、删除、遍历、清空等操作
- processAll遍历链表中的各异质节点，依次执行其process操作
- iterate能够使用自定义回调函数遍历链表中的各异质节点
- 插入删除节点更安全，拷贝节点也更安全：
- 已经在链表中的节点无法再次被插入到任何链表中
- 只能删除当前链表中的节点
- 节点间相互拷贝不会影响链表
- 在Debug模式下，节点先于链表删除会产生断言失败
- 本链表无法被复制（确保链表不会被意外破坏）
*/
class List
{
public:
/*! insert操作插入位置枚举 */
enum Position
{
Head, /*!< 链表首部 */
Tail /*!< 链表尾部 */
};
List();
~List();
/*!
在pos位置插入node节点
\param pos 插入位置，见Position
\param node 待插入节点的指针
\return 插入成功返回true，否则返回false
*/
bool insert(Position pos, IListNode *node);
/*!
在第index-1节点后插入node节点
\param index 插入位置，插入后该节点将处于index位置
\param node 待插入节点的指针
\return 插入成功返回true，否则返回false
*/
bool insertAt(int index, IListNode *node);
/*!
从链表中删除node节点
\param node 待删除节点的指针
\return 删除成功返回true，否则返回false
*/
bool remove(IListNode *node);
/*!
从链表中删除第index个节点
\param index 待删除节点的索引
\return 插入成功返回true，否则返回false
*/
bool removeAt(int index);
/*!
使用func回调函数遍历链表，param参数将传入回调函数中
\param func 回调函数指针
\param param 回调函数参数
\return 若遍历的func回调函数全部返回true，返回true，否则返回false
*/
bool iterate(callback func, void *param);
/*!
遍历链表，并调用每个节点的process函数
\param param 传入每个节点process函数的参数
\return 若每个节点的process都返回true，返回true，否则返回false
*/
bool processAll(void *param) const;
/*!
清空链表，但不释放节点
\return 成功返回true，否则返回false
*/
bool clear();
/*!
判断链表中是否存在节点node
\param node 待检测是否被包含在链表中的节点的指针
\return 链表中存在node返回true，否则返回false
*/
bool contains(const IListNode *node) const;
/*!
判断链表是否为空
\return 若链表空返回true，否则返回false
*/
bool isEmpty() const;
/*!
获得链表中节点个数
\return 链表中节点个数
*/
int count() const;
/*!
获得链表中位于index处的节点的指针
\param index 索引位置
\return 位于index处的节点的指针
*/
IListNode * at(int index) const;
public:
/*!
静态函数，用来处理节点（调用节点的process函数）
\param node 待处理节点的指针
\param param 传入node的process函数的参数
\return node的process返回值
*/
static bool process(IListNode *node, void *param);
private:
ListPrivate *list;
IListNode *head;
IListNode *tail;
private:
List(const List &list);//! 禁用拷贝构造函数
List &operator=(const List &list);//! 禁用赋值构造函数
private:
bool isolate(IListNode *node) const;
bool prepare(IListNode *node) const;
bool hasNode(const IListNode *node) const;
bool noOwner(const IListNode *node) const;
private:
static bool isolateCallback(IListNode *node, int index, void *param);
};
#endif
/*!
\file List.cpp
\author 刘宝
\version 1.0
\date 2010/12/3
\brief 异质链表List及其节点接口IListNode的实现
*/
#include <assert.h>
#include <stddef.h>
#include "List.h"
class ListPrivate
{
public:
ListPrivate() : _count(0) {}
inline void incCount() {++_count;}
inline void decCount() {--_count;}
inline void rstCount() {_count = 0;}
inline int count() const {return _count;}
inline bool isValidIndex(int index)
{
return (index >= 0 && index < _count) ?
true : false;
}
private:
int _count;
};
IListNode &IListNode::operator=(const IListNode &node)
{
/*! 阻断指针复制 */
return *this;
}
IListNode::~IListNode()
{
/*!
当IListNode还在List中时就销毁会触发此处断言。
请先从List中删除该节点再销毁该节点！
*/
assert(!owner && !prev && !next);
}
List::List() : list(new ListPrivate), head(0), tail(0)
{
}
List::~List()
{
(void)clear();
}
bool List::insert(Position pos, IListNode *node)
{
bool retVal = false;
if((pos == Head || pos == Tail) && prepare(node))
{
if(!head && !tail)//空链表时
head = tail = node;
else
{
assert(head && tail);
/*
此时链表中应当至少存在一个节点，
并且head和tail应当都不为NULL。
*/
switch(pos)
{
case Head://插入到头部
head->prev = node;
node->next = head;
head = node;
break;
case Tail://插入到尾部
tail->next = node;
node->prev = tail;
tail = node;
break;
default://不应该发生
assert(0);
}
}
list->incCount();//增加count计数
retVal = true;
}
return retVal;
}
bool List::insertAt(int index, IListNode *node)
{
bool retVal = false;
if(index == 0)
retVal = insert(Head, node);//相当于在头部插入node
else if(index == list->count())
retVal = insert(Tail, node);//相当于在尾部插入node
else
{
assert(head && tail);
/* 在第index-1个节点后插入node */
IListNode *prevNode = at(index - 1);
if(prevNode && prepare(node))
{
node->next = prevNode->next;
node->prev = prevNode;
assert(prevNode->next);//prevNode的next不应当为NULL
prevNode->next->prev = node;
prevNode->next = node;
list->incCount();//增加count计数
retVal = true;
}
}
return retVal;
}
bool List::remove(IListNode *node)
{
bool retVal = false;
if(hasNode(node))
{
if(head == node)
head = node->next;
if(tail == node)
tail = node->prev;
/* 修改node前后节点的相关指针 */
if(node->next)
node->next->prev = node->prev;
if(node->prev)
node->prev->next = node->next;
/* 孤立该节点 */
(void)isolate(node);
list->decCount();//减少count计数
retVal = true;
}
return retVal;
}
bool List::removeAt(int index)
{
return remove(at(index));
}
bool List::iterate(callback func, void *param)
{
bool retVal = false;
if(func && head && tail)
{
IListNode *iterator = head;
{
IListNode *tempPtr = NULL;
int index = 0;
/*
使用tempPtr缓存iterator->next指针是为了
使本函数能够遍历过程中删除节点。
*/
do
tempPtr = iterator->next; //缓存iterator->next指针到tempPtr
while(func(iterator, index++, param) && (iterator = tempPtr));
}
/* 遍历成功完成 */
if(!iterator) retVal = true;
}
return retVal;
}
bool List::clear()
{
bool retVal = false;
if(list->count() && (retVal = iterate(isolateCallback, this)))
{
list->rstCount(); /* 把计数器置0 */
head = 0;
tail = 0;
}
return retVal;
}
bool List::processAll(void *param) const
{
bool retVal = false;
if(head && tail)
{
IListNode *iterator = head;
/* 从head遍历全部，并执行process函数 */
while(iterator->process(param) && (iterator = iterator->next));
/* 遍历成功完成 */
if(!iterator) retVal = true;
}
return retVal;
}
bool List::contains(const IListNode *node) const
{
return hasNode(node);
}
bool List::isEmpty() const
{
return !list->count();
}
int List::count() const
{
return list->count();
}
IListNode *List::at(int index) const
{
IListNode *retVal = NULL;
/* 如果index有效 */
if(list->isValidIndex(index))
{
IListNode *iterator = head;
/* 从head开始寻找第index个节点 */
for(;index && (iterator = iterator->next); --index);
/* 遍历成功完成 */
if(!index) retVal = iterator;
}
return retVal;
}
bool List::process(IListNode *node, void *param)
{
return node ? node->process(param) : false;
}
bool List::isolate(IListNode *node) const
{
if(hasNode(node))
{
node->owner = NULL;
node->prev = NULL;
node->next = NULL;
return true;
}
else
return false;
}
bool List::prepare(IListNode *node) const
{
if(noOwner(node))
{
node->owner = const_cast<List *>(this);
node->prev = NULL;
node->next = NULL;
return true;
}
else
return false;
}
bool List::hasNode(const IListNode *node) const
{
return node ? node->owner == this : false;
}
bool List::noOwner(const IListNode *node) const
{
return node ? !node->owner : false;
}
bool List::isolateCallback(IListNode *node, int index, void *param)
{
List *self = (List *)param;
return self ? self->isolate(node) : false;
}
#include <iostream>
#include <assert.h>
#include "List.h"
using namespace std;
class SquareNode : public IListNode
{
public:
SquareNode(int length) : x(length) {}
protected:
bool process(void *param)
{
return cout << x * x << endl;
}
private:
int x;
};
class RoundNode : public IListNode
{
public:
RoundNode(int radius) : r(radius) {}
protected:
bool process(void *param)
{
return cout << 3.14 * r * r << endl;
}
private:
int r;
};
class RectangleNode : public IListNode
{
public:
RectangleNode(int length, int width) : x(length), y(width) {}
protected:
bool process(void *param)
{
return cout << x * y << endl;
}
private:
int x;
int y;
};
bool ListNodeProcessor(IListNode *node, int index, void *param)
{
cout << index << "->";
return List::process(node, param);
}
void TestList()
{
SquareNode square1(5), square2(7);
RoundNode round1(4), round2(6);
RectangleNode rect1(3, 7), rect2(4, 8);
List list;
assert(list.insert(List::Head, &square1));
assert(!list.insert(List::Head, &square1)); /*!< 重复插入链表内节点会失败 */
assert(list.remove(&square1));
assert(!list.processAll(NULL)); /*!< 对空链表遍历会失败 */
assert(list.insert(List::Head, &square1)); /*!< 从链表移出的节点可以再次插入 */
assert(list.insert(List::Tail, &round2));
assert(list.processAll(NULL));
assert(list.remove(&round2));
assert(list.processAll(NULL));
assert(list.insert(List::Head, &round2));
assert(list.remove(&round2));
assert(list.processAll(NULL));
assert(!list.insertAt(-1, &round1));
assert(!list.insertAt(list.count() + 1, &round1));
assert(list.insertAt(1, &round1));
assert(list.insertAt(1, &round2));
assert(list.count() == 3);
assert(list.processAll(NULL));
for(int i = 0; i < list.count(); ++i)
assert(List::process(list.at(i), NULL));
assert(list.iterate(ListNodeProcessor, NULL));
assert(!list.removeAt(-1));
assert(!list.removeAt(list.count()));
assert(list.removeAt(0));
assert(list.count() == 2);
assert(list.removeAt(list.count() - 1));
assert(list.count() == 1);
assert(!list.isEmpty());
assert(list.clear());
assert(list.isEmpty());
}
int main()
{
TestList();
// SquareNode node(1);
// SquareNode copyNode1 = node;
// SquareNode copyNode2(node);
// SquareNode assignNode(2);
// assignNode = node;
// cout << "testCopy:" << endl;
//
// SquareNode testNode(66);
// List list;
// assert(list.insertAt(0, &node));
// node = testNode;
return 0;
}
