最近学数据结构,于是尝试着去实现了一个 list 类,发现确实有很多问题,特别是类的继承这一块,有些问题搞不懂……
这个 list 类只是一个简单的实现,只提供了基本的功能,也没有边界检测什么的,越界访问的问题由使用者自己把握……
很多功能都是没有实现的,总得来说这是一个比较裸的 list 模板类,没有什么实用价值……
/* THE PROGRAM IS MADE BY PYY */
//#include <iostream>
//#include "class.h"
//using namespace std ;
//
//
// Decleration
//
template <class T>
class Node ;
template <class T>
class List ;
template <class T>
class const_Iterator ;
template <class T>
class Iterator ;
//
//
// Node
//
template <class T>
class Node {
friend class List<T> ;
friend class const_Iterator<T> ;
friend class Iterator<T> ;
private:
T elem ;
Node *prev ;
Node *next ;
Node (const T &t = *(new T), Node *p = 0, Node *n = 0)
: elem(t), prev(p), next(n) {}
} ;
//
//
// const_Iterator
//
template <class T>
class const_Iterator {
friend class List<T> ;
protected:
typedef const_Iterator<T> ci_t ;
public:
const_Iterator (Node<T> * n) : pNode(n) {}
const_Iterator (const ci_t &ci)
: pNode(ci.pNode) {}
const T & operator* () const { return pNode->elem ; }
const T * operator->() const { return &pNode->elem ; }
ci_t operator= (const ci_t &ci) { pNode = ci.pNode ; return *this ; }
// ++
ci_t & operator++() { pNode = pNode->next ; return *this ; }
ci_t operator++ (int) {
ci_t ci(*this) ;
pNode = pNode->next ;
return ci ;
}
// --
ci_t & operator--() { pNode = pNode->prev ; return *this ; }
ci_t operator--(int) {
ci_t ci(*this) ;
pNode = pNode->prev ;
return ci ;
}
// ==
bool operator== (const ci_t &ci) const {
return pNode == ci.pNode ;
}
bool operator!= (const ci_t &ci) const {
return !(*this == ci) ;
}
protected:
Node<T> *pNode ;
} ;
//
//
// Iterator
//
template <class T>
class Iterator: public const_Iterator<T> {
friend class List<T> ;
using const_Iterator<T>::pNode ; // 不加这句,codeblocks 就一直提示错误:
// error: 'pNode' was not declared in this scope|
public:
Iterator (Node<T> * n) : const_Iterator<T>(n) {}
Iterator (const Iterator &ci): const_Iterator<T>(ci) {}
Iterator operator= (const Iterator &ci) { pNode = ci.pNode; return *this ;}
T & operator* () { return const_Iterator<T>::pNode->elem ; }
T * operator->() { return &const_Iterator<T>::pNode->elem ; }
// 不重定义这些操作符,所有对 Iterator 的操作(++,--)的结果都会返回 基类,
// 导致无法实现这些 修改内容 的语句:erase (--end()) ;
// 编译器会提示,const_Iterator<T> 类无法转换为 Iterator<T> 类
Iterator & operator-- () {
pNode = pNode->prev ;
return *this ;
}
Iterator operator-- (int) {
Iterator itr(*this) ;
pNode = pNode->prev ;
return itr ;
}
Iterator & operator++ () {
pNode = pNode->next ;
return *this ;
}
Iterator operator++ (int) {
Iterator itr(*this) ;
pNode = pNode->next ;
return itr ;
}
} ;
//
//
// List, 简单实现,无错误检测,无边界检测
//
template <class T>
class List {
public:
typedef const_Iterator<T> const_iterator ;
typedef Iterator<T> iterator ;
public:
// Copy controy
List () { init () ; }
~List () {
clear () ;
delete head ;
delete tail ;
}
const List<T> & operator= (const List<T> &rhs) {
if (this == &rhs)
return *this ;
clear () ;
for (const_iterator itr = rhs.begin () ; itr != rhs.end() ; ++itr)
push_back (*itr) ;
return *this ;
}
// Iterators
iterator begin () { return iterator(head->next) ; }
const_iterator begin () const { return const_iterator(head->next) ; }
iterator end () { return iterator(tail) ; }
const_iterator end () const { return const_iterator(tail) ; }
// rbegin () ;
// rend () ;
// Capacity
bool empty () const { return !theSize ; }
int size () const { return theSize ; }
// max_size () ;
// resize () ;
// Element access
T front () { return *begin () ; }
const T front () const { return *begin () ; }
T back () { return *--end () ; }
const T back () const { return *--end () ; }
// Modifiers
// assign () ;
void push_front (const T &t) { insert (begin(), t) ; }
void pop_front () { erase (begin()) ; }
void push_back (const T &t) { insert (end(), t) ; }
void pop_back () { erase (--end()) ; }
// 只能修改 iterator 类指定的内容,如果 const_iterator 类传进来,就会提示
// 基类 无法转换为 继承类。从而导致编译不通过
iterator insert (iterator itr, const T &t) {
++theSize ;
Node<T> *pCurNode = itr.pNode ;
return iterator(
pCurNode->prev = pCurNode->prev->next =
new Node<T>(t, pCurNode->prev, pCurNode)) ;
}
iterator erase (iterator itr) {
Node<T> *curNode = itr.pNode ;
Node<T> *nextNode = curNode->next ;
curNode->prev->next = curNode->next ;
curNode->next->prev = curNode->prev ;
delete curNode ;
--theSize ;
return iterator(nextNode) ;
}
iterator erase (iterator start, iterator end) {
while (!empty() && (start != end))
start = erase (start) ;
return end ;
}
// swap
void clear () { erase (begin(), end()) ; }
/*
// Operations
splice
remove
remove_if
unique
merge
sort
reverse
// Allocator
get_allocator
*/
private:
Node<T> *head ;
Node<T> *tail ;
int theSize ;
void init () {
head = new Node<T> ;
tail = new Node<T> ;
head->next = tail ;
tail->prev = head ;
theSize = 0 ;
}
} ;