vector和list的使用及其模拟实现
一.vector使用及模拟实现。
1.vector简介。
vector和数组类似，拥有一段连续的内存空间，并且起始地址不变。
因此能高效的进行随机存取，时间复杂度为o(1);
但因为内存空间是连续的，所以在进行插入和删除操作时，会造成内存块的拷贝，时间复杂度为o(n)。
另外，当数组中内存空间不够时，会重新申请一块内存空间并进行内存拷贝。
注：vector相当于一个动态增长的数组。
2.vector的一些基本用法。
（1）.头文件包含。
使用时要在前面加上#include以包含所需的类文件vector。
（2）.变量声明。
1>.声明一个int向量以替代一个一维数组：vector 即声明了一个一维数组a[ ],数组大小没有给定，可以动态向里面添加或者删除。
2>.声明一个数组向量以代替一个二维数组：vector
3.具体的用法及函数调用。
用法：
（1）.push_back 在数组的最后添加一个数据
（2）.pop_back 去掉数组的最后一个数据
（3）.at 得到编号位置的数据
（4）.begin 得到数组头的指针
（5）.end 得到数组的最后一个单元+1的指针
（6）．front 得到数组头的引用
（7）.back 得到数组的最后一个单元的引用
（8）.max_size 得到vector最大可以是多大
（9）.capacity 当前vector分配的大小
（10）.size 当前使用数据的大小
（11）.resize 改变当前使用数据的大小，如果它比当前使用的大，者填充默认值
（12）.reserve 改变当前vecotr所分配空间的大小
（13）.erase 删除指针指向的数据项
（14）.clear 清空当前的vector
（15）.rbegin 将vector反转后的开始指针返回(其实就是原来的end-1)
（16）.rend 将vector反转构的结束指针返回(其实就是原来的begin-1)
（17）.empty 判断vector是否为空
（18）.swap 与另一个vector交换数据
详细的函数实现功能：其中vector.
v.clear() 移除容器中所有数据。
v.empty() 判断容器是否为空。
v.erase(pos) 删除pos位置的数据
v.erase(beg,end) 删除[beg,end)区间的数据
v.front() 传回第一个数据。
v.insert(pos,elem) 在pos位置插入一个elem拷贝
v.pop_back() 删除最后一个数据。
v.push_back(elem) 在尾部加入一个数据。
v.resize(num) 重新设置该容器的大小
v.size() 回容器中实际数据的个数。
v.begin() 返回指向容器第一个元素的迭代器
v.end() 返回指向容器最后一个元素的迭代器
注：具体用法和函数的调用会在后面的代码中详细体现
4.内存管理与效率。
（1）使用reserve()函数提前设定容量大小，避免多次容量扩充操作导致效率低下。
（2）size()告诉你容器中有多少元素。它没有告诉你容器为它容纳的元素分配了多少内存。
（3）capacity()告诉你容器在它已经分配的内存中可以容纳多少元素。那是容器在那块内存中总共可以容纳多少元素，而不是还可以容纳多少元素。如果你想知道一个vector或string中有多少没有被占用的内存，你必须从capacity()中减去size()。如果size和capacity返回同样的值，容器中就没有剩余空间了，而下一次插入（通过insert或push_back等）会引发上面的重新分配步骤。
（4）resize(Container::size_type n)强制把容器改为容纳n个元素。调用resize之后，size将会返回n。如果n小于当前大小，容器尾部的元素会被销毁。如果n大于当前大小，新默认构造的元素会添加到容器尾部。如果n大于当前容量，在元素加入之前会发生重新分配。
（5）reserve(Container::size_type n)强制容器把它的容量改为至少n，提供的n不小于当前大小。这一般强迫进行一次重新分配，因为容量需要增加。
5.vector的模拟实现。
代码：
Vector.h
#pragma once
#includefor(size_t i = 0;i < v.size();++i)
{
cout<" ";
}
cout<void test_vector1()
{
vector<int> v1;
v1.push_back(1);
v1.push_back(2);
v1.push_back(3);
v1.push_back(4);
vector<int>::iterator it = v1.begin();
while(it != v1.end())
{
if(*it % 2 == 0)
{
it=v1.erase(it);
}
else
{
++it;
}
}
print_vector(v1);
}
void test_vector2()
{
vector<int> v2;
v2.push_back(1);
v2.push_back(2);
v2.push_back(3);
v2.push_back(4);
v2.push_back(5);
v2.push_back(6);
v2.push_back(7);
v2.push_back(8);
v2.push_back(9);
print_vector(v2);
cout<<"capacity:"<3);
/*v2.resize(10,10);*/
print_vector(v2);
cout<<"capacity:"<void test_vector3()
{
vector<int> v3;
v3.push_back(1);
v3.push_back(2);
v3.push_back(3);
v3.push_back(4);
v3.push_back(5);
v3.push_back(6);
v3.push_back(7);
v3.push_back(8);
v3.push_back(9);
print_vector(v3);
cout<<"capacity:"<20);
print_vector(v3);
cout<<"capacity:"<template<class T>
class Vector
{
public:
//typedef T* Iterator;
typedef const T* Iterator;
Vector()
:_start(NULL)
,_finish(NULL)
,_endOfStorage(NULL)
{}
void PushBack(const T& x)
{
Iterator end = End();
Insert(end,x);
}
void PopBack()
{}
void Insert(Iterator& pos,const T& x)
{
size_t n = pos - _finish;
if(_finish == _endOfStorage)
{
size_t len = Capacity() == 0 ? 3 : Capacity()*2;
Expand(len);
}
pos = _start + n;
for(Iterator end = End(); end != pos;--end)
{
*end = *(end-1);
}
*pos = x;
++_finish;
}
Iterator End()
{
return _finish;
}
Iterator Begin()
{
return _start;
}
void Resize(size_t n,const T& val = T())
{
if(n < Size)
{
_finish = _start + n;
}
else
{
Reserve(n);
size_t len = n - Size();
for(size_t i = 0;i < len;++i)
{
PushBack(val);
}
}
}
void Reserve(size_t n)
{
Expand(n);
}
inline size_t Size()
{
return _finish - _start;
}
inline size_t Capacity()
{
return _endOfStorage - _start;
}
void Expand(size_t n)
{
const size_t size = Size();
const size_t capacity = Capacity();
if(n > capacity)
{
T* tmp = new T[n];
for(size_t i = 0;i< size;++i)
{
tmp[i] = _start[i];
}
delete _start;
_start = tmp;
_finish =_start + size;
_endOfStorage =_start+n;
}
}
T& operator[](size_t pos)
{
assert(pos < Size() );
return _start[pos];
}
const T& operator[](size_t pos)const
{
assert(pos < Size());
return _start[pos];
}
protected:
Iterator _start;
Iterator _finish;
Iterator _endOfStorage;
};
void TestVector()
{
Vector<int> v;
v.PushBack(1);
v.PushBack(2);
v.PushBack(3);
v.PushBack(4);
Vector<int>:: Iterator pos = v.Begin();
v.Insert(pos,10);
v.Insert(pos,20);
v.Insert(pos,30);
v.Insert(pos,40);
Vector<int>:: Iterator it = v.Begin();
while(it!=v.End())
{
cout<<*it<<" ";
++it;
}
cout< TestVector.cpp
#include二.list的使用及模拟实现。
1.list的简介。
list是一个线性双向链表结构，它的数据由若干个节点构成，每一个节点都包括一个信息块（即实际存储的数据）、一个前驱指针和一个后驱指针。它无需分配指定的内存大小且可以任意伸缩，这是因为它存储在非连续的内存空间中，并且由指针将有序的元素链接起来。由于其结构的原因，list 随机检索的性能非常的不好，因为它不像vector 那样直接找到元素的地址，而是要从头一个一个的顺序查找，这样目标元素越靠后，它的检索时间就越长。检索时间与目标元素的位置成正比。虽然随机检索的速度不够快，但是它可以迅速地在任何节点进行插入和删除操作。因为list 的每个节点保存着它在链表中的位置，插入或删除一个元素仅对最多三个元素有所影响，不像vector 会对操作点之后的所有元素的存储地址都有所影响，这一点是vector 不可比拟的。
注：list相当于一个双向循环链表。
2.list 的特点：
(1) 不使用连续的内存空间这样可以随意地进行动态操作；
(2) 可以在内部任何位置快速地插入或删除，当然也可以在两端进行push 和pop 。
(3) 不能进行内部的随机访问，即不支持[ ] 操作符和vector.at() ；
(4) 相对于verctor 占用更多的内存。
3.初学list：需要掌握的知识：
(1)定义一个list .
(2)向list中加入元素 .
(3)如何知道list是否为空 .
(4)如何使用for循环来遍历一个list .
(5)如何使用STL的通用算法for_each来遍历list.
(6)list成员函数begin() 和 end() 以及它们的意义 .
(7)iterator范围的概念和一个范围的最后一个位置实际上并不被处理这一事实 .
1>.第一：定义，插入，遍历打印。
代码实现如下：
#include
#include定义了一个字符串类型的list。需要包含提供STL的 list类的头文件#include ＜list＞即可；list的成员函数push_back()把一个对象放到一个list的后面，而 push_front()把对象放到前面。
我们想要遍历一个list，比如打印一个list中的所有对象来看看list上不同操作的结果。要一个元素一个元素的遍历一个list， 可以这样做：
A. 这个程序定义了一个iterator（类似指针），testiterator。它指向了这个list的第一个元素。 这可以调用testiterator.begin()来做到，它会返回一个指向list开头的iterator。然后把它和testiterator.end()的 返回值来做比较，到了那儿的时候就停下来。 容器的end()函数会返回一个指向容器的最后一个位置的iterator。 在上面的例子中，每一次执行for循环，我们就重复引用iterator来得到我们打印的字符串。
注意：不能用testiterator.begin()+2来指向list中的第三个对象，因为STL的list是以双链的list来实现的，所有的数据存放不一定是连续存放的。 它不支持随机存取。
B.使用STL的通用算法for_each()来遍历一个iterator的范围，然后调用PrintIt()来处理每个对象。 不需要初始化、比较和给iterator增量。for_each()完成了这些工作。执行于对象上的操作被很好的 打包在这个函数以外了，不用再做那样的循环了，代码更加清晰了。
第二：count()和count_if() 的基本使用
STL的通用算法count()和count_it()用来给容器中的对象记数。就象for_each()一样，count()和count_if() 算法也是在iterator范围内来做的。
#include
#includecount()算法统计等于某个值的对象的个数。count_if() 带一个函数对象的参数。函数对象是一个至少带有一个operator()方法的类。有些STL算法作为参数接收函数对象并调用这个函数对象的operator()方法。函数对象被约定为STL算法调用operator时返回true或false。它们根据这个来判定这个函数。举个例子会 说的更清楚些。count_if()通过传递一个函数对象来作出比count()更加复杂的评估以确定一个对象是否应该被记数。
4.list的模拟实现。
代码如下：
List.h
#pragma once
#include
#include//void test_list()
//{
// list l1;
// l1.push_back(1);
// l1.push_back(2);
// l1.push_back(3);
// l1.push_back(4);
//
// print_list(l1);
//
// list::iterator it1 = l1.begin();
// while(it1 != l1.end())
// {
// cout<<*it1<<" ";
// if(*it1 % 2 == 0)
// {
// (*it1)*=2;
// }
// it1++;
// }
// cout<
//
// print_list(l1);
//
//
// list::reverse_iterator it2 = l1.rbegin();
// while(it2!=l1.rend())
// {
// cout<<*it2<<" ";
// it2++;
// }
// cout<
//}
//void test_list()
//{
// list l1;
// l1.push_back(1);
// l1.push_back(2);
// l1.push_back(3);
// l1.push_back(4);
//
// //删除所有偶数
// //迭代器失效==产生野指针
// list::iterator it1 = l1.begin();
// while(it1 != l1.end())
// {
// if(*it1 % 2 == 0)
// {
// it1 = l1.erase(it1);//erase有返回值，返回最近删除元素的下一个位置
// }
// else
// {
// ++it1;
// }
// }
// print_list(l1);
//
// cout<
// list l2;
// cout<
//}
//void test_list()
//{
// list l1;
// l1.push_back(1);
// l1.push_back(2);
// l1.push_back(3);
// l1.push_back(4);
//
// print_list(l1);
//
// l1.assign(10,1);//clear + push_back
// print_list(l1);
//
// list l2;
// l2.push_back(10);
// l2.push_back(20);
// l2.push_back(20);
// l2.push_back(30);
//
// l1.assign(++l2.begin(),--l2.end());
// print_list(l1);
//
// string s("你好");
// l1.assign(s.begin(),s.end());
// print_list(l1);
// char buf[5]={0};
// buf[0] = -60;
// buf[1] = -29;
// buf[2] = -70;
// buf[3] = -61;
//
// cout<
// print_list(l1);
//}
template<class T>
struct __ListNode
{
T _data;
__ListNode* _next;
__ListNode* _prev;
__ListNode(const T& x)
:_data(x)
,_next(NULL)
,_prev(NULL)
{}
};
template <class T,class Ref,class Ptr>
struct __ListIterator
{
typedef __ListNode Node;
typedef __ListIterator Self;
__ListIterator(Node* node)
:_node(node)
{}
Ref operator *()
{
return _node->_data;
}
Ptr operator ->()
{
return &(_node->_data);
}
bool operator== (const Self &s)
{
return _node == s._node;
}
bool operator!=(const Self &s)
{
return _node!=s._node
}
Self& operator++()
{
_node = _node->_next;
return *this;
}
Self& operator--()
{
_node = _node->_prev;
return *this;
}
};
template<class T>
class List
{
typedef __ListNode Node;
public:
typedef __ListIterator Iterator;
typedef __ListIteratorconst T&,const T*> ConstIterator;
Iterator Begin()
{
return _head->_next;
}
Iterator End()
{
return _head;
}
ConstIterator Begin() const
{
return _head->_next;
}
ConstIterator End() const
{
return _head;
}
List()
{
_head = new Node(T());
_head->_next = _head;
_head->_prev = _head;
}
List(const List& l)
{
_head = new Node(T());
_head->_next = _head;
_head->_prev = _head;
ConstIterator it = l.Begin();
while(it!=l.End())
{
PushBack(*it);
++it;
}
}
~List()
{
Clear();
delete _head;
_head = NULL;
}
void Clear()
{
Iterator it = Begin();
while(it!=End())
{
Node* del = it._node;
++it;
delete del;
}
_head->_next = _head;
_head->_prev = _head;
}
void PushBack(const T& x)
{
Insert(End(),x);
}
void PushFront(const T& x)
{
Insert(Begin(),x);
}
void PopBack()
{
Erase(--End());
}
void PopFront()
{
Erase(Begin());
}
void Insert(Iterator pos,const T& x)
{
Node* cur = pos._node;
Node* prev = cur->_prev;
Node* tmp = new Node(x);
prev->_next = tmp;
tmp->_prev =prev;
tmp->_next = cur;
cur->_prev = prev;
}
Iterator Erase(Iterator& pos)
{
assert(pos!=End());
Node* prev = (pos._node)->_prev;
Node* next = (pos._node)->_next;
prev->_next = next;
next->_prev = prev;
delete pos._node;
pos._node= prev;
return Iterator(next);
}
protected:
Node* _head;
};
void PrintList(const List<int>& l)
{
List<int>::ConstIterator it = l.Begin();
while(it!= l.End())
{
cout<<*it<<" ";
++it;
}
cout<void TestList()
{
List<int> l;
l.PushBack(1);
l.PushBack(2);
l.PushBack(3);
l.PushBack(4);
PrintList(l);
List<int>:: Iterator it = l.Begin();
while(it != l.End())
{
if(*it%2 == 0)
{
l.Erase(it);
}
++it;
}
PrintList(l);
} TestList.cpp
#include三.vector和list的总结与比较。
1.vector为存储的对象分配一块连续的地址空间，因此对vector中的元素随机访问效率很高。在vecotor中插入或者删除某个元素，需要将现有元素进行复制，移动。如果vector中存储的对象很大，或者构造函数复杂，则在对现有元素进行拷贝时开销较大，因为拷贝对象要调用拷贝构造函数。对于简单的小对象，vector的效率优于list。vector在每次扩张容量的时候，将容量扩展2倍，这样对于小对象来说，效率是很高的。
2.list中的对象是离散存储的（循环双向链表），随机访问某个元素需要遍历list。在list中插入元素，尤其是在首尾插入元素，效率很高，只需要改变元素的指针。
综上所述：
vector适用：对象数量变化少，简单对象，随机访问元素频繁
list适用：对象数量变化大，对象复杂，插入和删除频繁
最大的区别是,list是双向的，而vector是单向的。
因此在实际使用时，如何选择这两个容器中哪一个，应根据你的需要而定，一般应遵循下面的原则：
1、如果你需要高效的随即存取，而不在乎插入和删除的效率，使用vector。
2、如果你需要大量的插入和删除，而不关心随即存取，则应使用list。