系列文章目录
前言
前言
全局函数
void destroy(first, last); 指针/迭代器
construct(position, T());
dest_last copy(sour_first, sour_last, dest_first);
dest_last uninitialized_copy(sour_first, sour_last, dest_first);
copy_backward(sour_first, sour_last, dest_last);
fill(first, last, T());
dest_last uninitialized_fill_n(dest, n, T());
distance();
vector
说明
array是静态空间，一旦配置了就不能改变；vector是动态空间，随着元素的加入，他的内部机制会自行扩容空间以容纳新元素。
“配置新空间 / 数据移动 / 释还旧空间”
// 显示总的存储空间
size_type capacity() const;
reference front();
reference back();
void push_back(const T& x);
void pop_back();
// 删除position所指元素，返回position位置的迭代器
iterator erase(iterator position);
// 删除[first, last)放回first位置的迭代器
iterator erase(iterator first, iterator last);
// 若new_size<size()，则删除后面的元素，否则在后面新增元素x
void resize(size_type new_size, const T& x);
// 调用resize(new_size, T())
void resize(size_type new_size);
void clear();
// 在position的位置向后插入n个x
void insert(iterator position, size_type n, const T& x);
代码概览
<std_vector.h>
// alloc 是 SGI STL的空间适配器
template<class T, class Alloc = alloc>
class vector
{
public:
// vector 的嵌套型别定义
typedef T value_type;
typedef value_type* pointer;
typedef value_type* iterator;
typedef value_type& reference;
typedef size_t size_type;
typedef ptrdiff_t difference_type;
protected:
// 以下simple_alloc是SGI STL的空间配置器
typedef simple_alloc<value_type, Alloc> data_allocator;
iterator start; // 表示目前使用空间的头
iterator finish; // 表示目前使用空间的尾
iterator end_of_storage; // 表示目前可用空间的尾
void insert_aux(iterator position, const T& x);
void deallocate()
{
if (start)
data_allocator::deallocate(start, end_of_storage - start);
}
void fill_initialize(size_type n, const T& value)
{
start = allocate_and_fill(n, value);
finish = start + n;
end_of_storage = finish;
}
public:
iterator begin()
{
return start;
}
iterator end()
{
return finish;
}
size_type size()
{
return size_type(end() - begin());
}
size_type capacity() const
{
return size_type(end_of_storage - begin());
}
bool empty() const
{
return begin() == end();
}
reference operator[](size_type n)
{
return *(begin() + n);
}
vector() : start(0), finish(0), end_of_storage(0) {}
vector(size_type n, const T& value)
{
fill_initialize(n, value);
}
vector(int n, const T& value)
{
fill_initialize(n, value);
}
vector(long n, const T& value)
{
fill_initialize(n, value);
}
explicit vector(size_type n)
{
fill_initialize(n, T());
}
~vector()
{
destroy(start, finish); //全局函数
deallocate();
}
reference front()
{
return *begin();
}
reference back()
{
return *end();
}
void push_back(const T& x)
{
if (finish != end_of_storage){
construct(finish, x); //全局函数
++finish;
} else {
insert_aux(end(), x);
}
}
void pop_back()
{
--finish;
destroy(finish); //全局函数
}
iterator erase(iterator position)
{
if (position + 1 != end()){
copy(position+1, finish, position);
}
--finish;
destroy(finish); //全局函数
return position;
}
iterator erase(iterator first, iterator last)
{
iterator i = copy(last, finish, first); //copy是全局函数
destroy(i, finish); //destroy是全局函数
finish = finish - (last - first);
return first;
}
void resize(size_type new_size, const T& x)
{
if (new_size < size())
erase(begin() + new_size, end());
else
insert(end(), new_size-size(), x);
}
void resize(size_type new_size)
{
resize(new_size, T());
}
void clear()
{
erase(begin(), end());
}
void insert(iterator position, size_type n, const T& x);
protected:
// 配置空间并填满
iterator allocate_and_fill(size_type n, const T& x)
{
iterator result = data_allocator::allocate(n);
uninitialized_fill_n(result, n, x); //全局函数
return result;
}
};
template<class T, class Alloc>
void vector<T, Alloc>::insert_aux(iterator position, const T& x)
{
if (finish != end_of_storage) {
// 在备用空间起始处构造一个元素，并以vector最后一个元素值为其初值
construct(finish, *(finish-1));
++finish;
T x_copy = x;
copy_backward(position, finish-2, finish-1);
*position = x_copy;
} else {
const size_type old_size = size();
const size_type len = old_size != 0 ? 2*old_size : 1;
iterator new_start = data_allocator::allocator(len);
iterator new_finish = new_start;
try{
new_finish = uninitialized_copy(start, position, new_start);
construct(new_finish, x);
++new_finish;
new_finish = uninitialized_copy(position, finish, new_finish);
} catch (...) {
destroy(new_start, new_finish);
data_allocator::deallocator(new_start, len);
throw;
}
destroy(begin(), end());
deallocate();
start = new_start;
finish = new_finish;
end_of_storage = start + len;
}
}
/*
* uninitialized_copy是将构造空间的数据复制到未构造空间上
* copy是将一个数据复制到另一个数据上，两个都已构造
*/
template<class T, class Alloc>
void vector<T, Alloc>::insert(iterator position, size_type n, const T& x)
{
if (n != 0){
if (size_type(end_of_storage - finish) >= n) {
// 备用空间大于等于“新增元素个数”
T x_copy = x;
const size_type elems_after = finish - position;
iterator old_finish = finish;
if (elems_after > n){
// 插入点之后的现有元素个数大于新增元素个数
uninitialized_copy(finish - n, finish, finish);
finish += n;
copy_backward(position, old_finish - n, old_finish);
fill(position, position+n, x_copy); // 从插入点开始填入新值
} else {
// 插入点之后的现有元素个数小于等于新增元素个数
uninitialized_fill_n(finish, n-elems_after, x_copy);
finish += n - elems_after;
uninitialized_copy(position, old_finish, finish);
finish += elems_after;
fill(position, old_finish, x_copy);
}
} else {
// 备用空间小于“新增元素个数”
// 首先决定新长度
const size_type old_size = size();
const size_type len = old_size + max(old_size, n);
// 以下配置新的vector空间
iterator new_start = data_allocator::allocate(len);
iterator new_finish = new_start;
__STL_TRY {
// 先将旧vector的值插入点之前的元素复制到新空间
new_finish = uninitialized_copy(start, position, new_start);
// 再将新元素（初值为n）填入新空间
new_finish = uninitialized_fill_n(new_finish, n, x);
// 再将旧vector的插入点之后的元素复制到新空间
new_finish = uninitialized_copy(position, finish, new_finish);
}
# ifdef __STL_USE_EXCEPTIONS
catch (...){
// 如有异常发生，实现“commit or rollback” sematics
destroy(new_start, new_finish);
data_allocator::deallocate(new_start, len);
}
# endif /* __STL_USE_EXCEPTIONS */
// 以下清楚并释放旧的vector
destroy(start, finish);
deallocate();
start = new_start;
finish = new_finish;
end_of_storage = new_start + len;
}
}
}
list
说明
list内部用一个双向循环链表实现，node即为end()始终指向一个空节点，循环链表的标记
成员函数(public)：
iterator begin();
iterator end();
bool empty();
size_type size();
reference front();
reference back();
void push_back(const T&);
void push_front(const T&);
// 在position位置的前方插入元素x, 返回指向x的迭代器(它应该在position的前方)
iterator insert(iterator position, const T& x);
// erase position指向的元素，返回一个迭代器，该迭代器指向position后面那个元素
iterator erase(iterator position);
void pop_front();
void pop_back();
void clear();
// 移除元素值为x的元素，只移除一个并且是第一个值为x的元素
void remove(const T&x);
// 移除数值相同的连续元素，只有“连续而相同的元素”，才会被移除剩一个
void unique();
// 将i所指移动到position所指之前，position和i可指向同一个list
void splice(iterator position, list&, iterator i);
// 将[first, last)内的所有元素接移动到position所指位置之前
// position和[first, last)可指向同一个list，position不能在[first, last)内部
void splice(iterator position, list&, iterator first, iterator last)；
// 将x的元素移动到*this上
void merge(list<T, Alloc>&x);
void reverse();
void sort(); 这个实现有点东西
代码概览
以下为删减后的代码，去除了一些继承、条件编译、traits等，方便阅读
template<class T>
struct __list_node
{
typedef void* void_pointer;
void_pointer prev; //类型为void，设为__list_node<T>*不用再类型转化了
void_pointer next;
T data;
};
template<class T, class Ref, class Ptr>
struct __list_iterator
{
typedef __list_iterator<T, T&, T*> iterator;
typedef __list_iterator<T, Ref, Ptr> self;
typedef bidirectional_iterator_tag iterator_category;
typedef T value_type;
typedef Ptr pointer;
typedef Ref reference;
typedef __list_node<T>* link_type;
typedef size_t size_type;
typedef ptrdiff_t difference_type;
link_type node;
//constructor
__list_iterator(link_type x) : node(x) {}
__list_iterator() {}
__list_iterator(const iterator& x) : node(x.node) {}
bool operator==(const self& x) const
{
return node == x.node;
}
bool operator!=(const self& x) const
{
return node != x.node;
}
// 以下对迭代器取值(dereference)，取的时节点的数据值
reference operator*() const
{
return node->data;
}
// 以下是迭代器的成员存取(member access)运算子的标准做法
pointer operator->() const
{
return &( operator*() );
}
// 返回左值
self& operator++()
{
node = (link_type)(node->next);
return *this;
}
// 返回右值
self operator++(int)
{
self tmp = *this;
++*this;
return tmp;
}
self& operator--()
{
node = (link_type)(node->prev);
return *this;
}
self operator--(int)
{
self tmp = *this;
--*this;
return tmp;
}
};
template<class T, class Alloc = alloc>
class list
{
protected:
typedef __list_node<T> list_node;
typedef simple_alloc<list_node, Alloc> list_node_allocator;
public:
typedef list_node* link_type;
protected:
link_type node;
// 配置一个节点并传回
link_type get_node()
{
return list_node_allocator::allocate();
}
// 释放一个节点
void put_node(link_type p)
{
list_node_allocator::deallocate(p);
}
// 产生(配置并构造)一个节点，带有元素值
link_type create_node(const T& x)
{
link_type p = get_node();
construct(&p->data, x); //全局函数 构造/析构基本工具
return p;
}
// 销毁(析构并释放)一个节点
void destroy_node(link_type p)
{
destroy(&p->data); // 全局函数
put_node(p);
}
void empty_initialize()
{
node = get_node(); //配置一个空间节点，令node指向它
node->next = node;
node->prev = node;
}
// 将[first, last)内的所有元素 移动 到position之前
void transfer(iterator position, iterator first, iterator last)
{
if (position == last) return ;
(link_type((last.node)->prev))->next = position.node;
(link_type((first.node)->prev))->next = last.node;
(link_type((position.node)->prev))->next = first.node;
link_type tmp = link_type(position.node->prev);
position.node->prev = last.node->prev;
last.node->prev = first.node->prev;
first.node->prev = tmp;
}
public:
iterator begin()
{
return (link_type)(node->next);
}
iterator end()
{
return node;
}
bool empty() const
{
return node->next == node;
}
size_type size() const
{
size_type result = 0;
distance(begin(), end(), result); //全局函数
return result;
}
// 取头节点的内容(元素值)
reference front()
{
return *begin();
}
// 取尾节点的内容(元素值)
reference back()
{
return *(--end());
}
void push_back(const T& x)
{
insert(end(), x);
}
void push_front(const T& x)
{
insert(begin(), x);
}
iterator insert(iterator position, const T& x)
{
link_type tmp = create_node(x); //产生一个节点(设妥内容为x)
tmp->next = position.node;
tmp->prev = position.node->prev;
(link_type(position.node->prev))->next = tmp;
position.node->prev = tmp;
return tmp;
}
iterator erase(iterator position)
{
link_type next_node = link_type(position.node->next);
link_type prev_node = link_type(position.node->prev);
prev_node->next = next_node;
next_node->prev = prev_node;
destroy_node(position.node);
return iterator(next_node);
}
// 移除头节点
void pop_front()
{
erase(begin());
}
// 移除尾节点
void pop_back()
{
// erase(--end()); 可行？
iterator tmp = end();
erase(--tmp);
}
void clear();
void remove(const T&);
void unique();
// 将x接合于position所指位置之前。x必须不同于*this
void splice(iterator position, list& x)
{
if (!x.empty()){
transfer(position, x.begin(), x.end());
}
}
// 将i所指元素接合于position所指位置之前。position和i可指向同一个list
void splice(iterator position, list&, iterator i)
{
iterator j = i;
++j;
if (position == i || position == j) return ;
transfer(position, i, j);
}
// 将[first, last)内的所有元素接合于position所指位置之前
// position和[first, last)可指向同一个list，不能再内
void splice(iterator position, list&, iterator first, iterator last)
{
if (first != last)
transfer(position, first, last);
}
void merge(list<T, Alloc>& x);
void reverse();
void sort();
list() { empty_initialize(); } //产生一个空链表
~list();
};
// 清除所有节点
template<class T, class Alloc>
void list<T, Alloc>::clear()
{
link_type cur = (link_type) node->next; // begin()
while (cur != node){ // 遍历每一个节点
link_type tmp = cur;
cur = (link_type) cur->next;
destroy_node(tmp); // 销毁（析构并释放）一个节点
}
node->next = node;
node->prev = node;
}
// 将数值为value之所有元素移除
template<typename T, typename Alloc>
void list<T, Alloc>::remove(const T& value)
{ /*
link_type cur = (link_type) node->next; // begin()
while (cur != node){
if (cur->data == value){
link_type tmp = cur;
link_type prev_node = tmp->prev;
link_type next_node = tmp->next;
prev_node->next = next_node;
next_node->prev = prev_node;
cur = (link_type) cur->next;
destroy_node(tmp);
} else {
cur = (link_type) cur->next;
}
}
*/
iterator first = begin();
iterator last = end();
while (first != last) {
iterator next = first;
++next;
if (*first == value) erase(first);
first = next;
}
}
// 移除数值相同的连续元素，只有“连续而相同的元素”，才会被移除剩一个
template<typename T, typename Alloc>
void list<T, Alloc>::unique()
{
iterator first = begin();
iterator last = end();
if (first == last) return ; //空链表
iterator next = first;
while (++next != last){ //遍历每一个节点
if (*first == *next){ //如果元素相同
erase(next); //移除
} else {
first = next;
}
next = first;
}
}
// merge()将x合并到*this身上。两个lists的内容都必须像经过递增排序
template<class T, class Alloc>
void list<T, Alloc>::merge(list<T, Alloc>& x)
{
iterator first1 = begin();
iterator end1 = end();
iterator first2 = x.begin();
iterator end2 = x.end();
// 两个lists都已经递增排序
while (first != last1 && first2 != last2){
if (*first2 < *first1){
iterator next = first2;
transfer(first1, first2, ++next);
first2 = next;
} else {
++first1;
}
}
if (first2 != last2) transfer(last1, first2, last2);
}
// reverse()将*this的内容逆向重置
template<class T, class Alloc>
void list<T, Alloc>::reverse()
{
//以下判断，如果是空链表，或仅有 一个元素，就不进行任何操作
//使用size()==1 || size() == 1判断较慢
if (node->next == node || link_type(node->next)->next = node)
return ;
iterator first = begin();
++first;
while (first != end()){
iterator old = first;
++first;
transfer(begin(), old, first);
}
}
// list不能使用STL算法sort()，必须使用自己的sort() member function，
// 因为STL算法sort()只接受RandomAccessIterator，本函数采用quick sort
template<class T, class Alloc>
void list<T, Alloc>::sort()
{
//以下判断，如果是空链表，或仅有 一个元素，就不进行任何操作
//使用size()==1 || size() == 1判断较慢
if (node->next == node || link_type(node->next)->next = node)
return ;
// 一些新的lists，作为中介数据存放区
list<T, Alloc> carry;
lsit<T, Alloc> counter[64];
int fill = 0;
while (!empty()){
carry.splice(carry.begin(), *this, begin());
int i = 0;
while (i < fill && !counter[i].empty()) {
counter[i].merge(carry);
carry.swap(counter[i++]);
}
carry.swap(counter[i]);
if ( i == fill) ++fill;
}
for (int i = 1; i < fill; ++i){
counter[i].merge(counter[i-1]);
}
swap(counter[fill-1]);
}
扫一扫
279
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
