stl源码剖析 详细学习笔记priority_queue slist

//

//  priority_queue.cpp

//  笔记

//

//  Created by fam on 15/3/16.

//

//

//---------------------------15/03/16----------------------------

//priority_queue

{

/*

priority_queue概述:

同正常队列一样,队尾进,队首出,不过不是先进后出,

有权值的概念,所以会自动排序(并不是全部排序,只要保证队

首值最大即可,权值最高的最先出队列,这里用的是堆来保证队首

的值

*/

template<class T,
class Sequence = vector<T>,

class Compare = less<typename Sequence::value_type> >

class priority_queue

{

public:

typedef typename Sequence::value_type value_type;

typedef typename Sequence::size_type size_type;

typedef typename Sequence::reference reference;

typedef typename Sequence::const_reference const_reference;

protected:

Sequence c;

Compare comp;

public:

priority_queue() : c(){};

//explict
可以有效防止隐式转化

explicit priority_queue(const Compare& x) : c(), comp(x){}

//下面都是直接调用heap算法来直接实现堆的操作

template<class InputIterator>

priority_queue(InputIterator first, InputIterator last,
const Compare& x)

:c(first,last), comp(x){ make_heap(c.begin(), c.end(), comp);}

template< class InputIterator>

priority_queue(InputIterator first, InputIterator last)

: c(first, last) {make_heap(c.begin(), c.end(), comp);}

bool empty() const {return c.empty();}

size_type size()
const {return c.size();}

const_reference top()
const {return c.front();}

void push(const value_type& x)

{

__STL_TRY

{

c.push_back(x);

push_heap(c.begin(), c.end(), comp);

}

__STL_UNWIND(c.clear());

}

void pop()

{

__STL_TRY

{

pop_heap(c.begin(), c.end(), comp);

c.pop_back();

}

__STL_UNWIND(c.clear());

}

/*

总结:

同queue
不提供迭代器。

不同queue,底层实现是用vector实现的(queue底层是deque实现的)

原因:queue每次进队列都在队尾,出队列都在队首,频繁地对头尾进行操作,

deque比vector性能好很多

priority_queue虽然也是队尾进,队首出,但是不可避免的是每次都要调整位置,

所以采用堆加vector是很好的选择(deque的随机访问是要比vector慢的),采用

堆每次插入,取出,都只用log(n)的时间,所以很好.

*/

};

}

//slist

{

/*

slist概述:

list是双向链表(double linked list),slist是单向链表

slist的迭代器属于单向的ForwardIterator,所以功能被限制了很多

但是耗用的空间小,操作更快.(我们大部分人最先接触的链表数据结构就是单向链表)

slist不提供push_back(),

*/

//__slist_node

struct __slist_node_base

{

__slist_node_base* next;

};

template <class T>

struct __slist_node :
public __slist_node_base

{

T data;

};

//添加一个节点(new_node)到prev_node之后

inline __slist_node_base* __slist_make_link(

__slist_node_base* prev_node,

__slist_node_base* new_node)

{

new_node->next = prev_node->next;

prev_node->next = new_node;

return new_node;

}

//通过循环判断node节点之后(包括node节点)一共有多少节点

inline size_t __slist_size(__slist_node_base* node)

{

size_t result =
;

; node = node->next)

++result;

return result;

}

//__slist_iterator

struct __slist_iterator_base

{

typedef size_t size_type;

typedef ptrdiff_t difference_type;

typedef forward_iterator_tag iterator_category;

//这里用基类创建一个节点

__slist_node_base* node;

__slist_iterator_base(__slist_node_base* x) :node(x){}

//相当于++操作

void incr() { node = node->next; }

//迭代器是否相等取决于他们的节点是否相等

bool operator==(const __slist_iterator_base& x)
const

{

return node == x.node;

}

bool operator!=(const __slist_iterator_base& x)
const{

return node != x.node;

}

};

//T: class Ref class& Ptr  class*

template<class T,
class Ref, class Ptr>

struct __slist_iterator :
public __slist_iterator_base

{

typedef __slist_iterator<T, T&, T*>     iterator;

typedef __slist_iterator<T,
const T&, const T*>     const_iterator;

typedef __slist_iterator<T, Ref, Ptr>   self;

typedef T   value_type;

typedef Ptr pointer;

typedef Ref reference;

//节点类型

typedef __slist_node<T> list_node;

__slist_iterator(list_node* x) : __slist_iterator_base(x) {}

__slist_iterator() : __slist_iterator_base(){}

__slist_iterator(const iterator& x) : __slist_iterator_base(x.node) {}

//node是__slist_node_base类型
需要强制转化

reference
operator*() const {return ((list_node*) node)->data;}

pointer
operator->() const {return &(operator*());}

self&
operator++()

{

incr();

return *this;

}

self
operator++(int)

{

self temp = *this;

incr();

return temp;

}

//并没有operator--操作

};

//class slist

template< class T,
class Alloc = allic>

class slist

{

public:

typedef T value_type;

typedef value_type* pointer;

typedef const value_type* const_pointer;

typedef value_type& reference;

typedef const value_type& const_reference;

typedef size_t size_type;

typedef ptrdiff_t difference_type;

typedef __slist_iterator<T, T&, T*> iterator;

typedef __slist_iterator<T,
const T&, const T*> const_iterator;

private:

typedef __slist_node<T> list_node;

typedef __slist_node_base list_node_base;

typedef __slist_iterator_base iterator_base;

typedef simple_alloc<list_node, Alloc> list_node_allocator;

//申请内存并调用构造函数

static list_node* create_node(const value_type& x)

{

list_node* node = list_node_allocator::allocate();

__STL_TRY

{

construct(&node->data, x);

node->next=;

}

__STL_UNWIND(list_node_allocator::deallocate(node));

return node;

}

static void destroy_node(list_node* node)

{

destroy(&node->data);

list_node_allocator::deallocate(node);

}

private:

list_node_base head;

public:

slist() { head.next =
; }

//clear()是循环删除所有节点

~slist() {clear();}

iterator begin() {return iterator((list_node*)head.next);}

//强制转化一个0为iterator类型表示end

//最开始的时候,head.next等于0
表示末尾;

iterator end() {);}

size_type size()
const {return __slist_size(head.next);}

bool empty() const {return head.next ==
;}

void swap(slist& L)

{

list_node_base* tmp =head.next;

head.next = L.head.next;

L.head.next = tmp;

}

public:

reference front() {return ((list_node*) head.next)->data;}

void push_front(const value_type& x)

{

__slist_make_link(&head, create_node(x));

}

void pop_front()

{

list_node* node = (list_node*) head.next;

head.next = node->next;

destroy_node(node);

}

};

/*

总结:

同deque一样,我还是不知道为什么在迭代器中会有self和iterator两个typedef

为什么要特地弄出两个基类？
这样的好处貌似是一个链表可以存放不同的数据类型，但是

并没有用啊。在使用slist<T>来声明定义变量时就确定了类型了。

别的没什么特别的技巧,就是一个很普通的list

*/

}