STL库里面的vector定义如上
什么是vector，通俗的来讲，vector就想数组一样，vector也采用的连续存储空间来存储元素。可以像数组一样访问，它的大小是可以动态改变的，而且它的大小会被容器自动处理。
一、vector主要的一些成员函数：
1.1 构造函数
1.2 迭代器
使用迭代器来打印vector里的内容，当然还有反向迭代器等等，这里只演示一种。
1.3 容量接口
void Test2()
{
int a[10] = { 0,1,2,3,4,5,6,7,8,9 };
vector<int> v1(a, a + sizeof(a) / sizeof(a[0]));//区间构造
cout << v1.size() << endl;//获取数据个数
cout << v1.capacity() << endl;//获取容量大小
cout << v1.empty() << endl;//判断是否为空
for (auto e : v1)
{
cout << e << " ";
}
cout << endl;
v1.resize(20);//只将size改成20，默认填充0
cout << v1.size() << endl;//获取容量大小
for (auto e : v1)
{
cout << e << " ";
}
cout << endl;
v1.resize(25, 100);//将size改成20，其余的填充成100
cout << v1.size() << endl;//获取容量大小
for (auto e : v1)
{
cout << e << " ";
}
cout << endl;
v1.resize(5);//将size改成5，后面的多余元素舍掉
cout << v1.size() << endl;//获取容量大小
for (auto e : v1)
{
cout << e << " ";
}
cout << endl;
v1.reserve(30);//仅仅将capacity改成30，size不变
cout << v1.capacity() << endl;//获取容量大小
}运行结果：
注意：
reserve只负责开辟空间，如果确定知道需要用多少空间，reserve可以缓解vector增容等等代价缺陷问题。
resize在开空间的同时还会进行初始化，影响size。
1.4 元素访问接口
1.5 修改接口
void Test4()
{
int a[10] = { 0,1,2,3,4 };
vector<int> v1(a, a + sizeof(a) / sizeof(a[0]));//区间构造
v1.push_back(5);//尾插
v1.push_back(6);
v1.push_back(7);
v1.push_back(8);
for (auto e : v1)
{
cout << e << " ";
}
cout << endl;
v1.insert(v1.begin() + 3, 30);//在下标为3的位置插入一个30
for (auto e : v1)
{
cout << e << " ";
}
cout << endl;
v1.assign(10, 5);//将新内容填入vector，覆盖旧的内容，并改变size的大小
for (auto e : v1)
{
cout << e << " ";
}
cout << endl;
}运行结果：
迭代器的主要作用就是让算法能够不用关心底层数据结构，其底层实际就是一个指针，或者是对指针进行了封装，比如：vector的迭代器就是原生态指针T* 。因此迭代器失效，实际就是迭代器底层对应指针所指向的空间被销毁了，而使用一块已经被释放的空间，造成的后果是程序崩溃(即如果继续使用已经失效的迭代器，程序可能会崩溃)。
对于vector可能会导致其迭代器失效的操作有：
1. 会引起其底层空间改变的操作，都有可能是迭代器失效，比如：resize、reserve、insert、assign、push_back等。
2. 指定位置元素的删除操作--erase
erase删除pos位置元素后，pos位置之后的元素会往前搬移，没有导致底层空间的改变，理论上讲迭代器不应该会失效，但是：如果pos刚好是最后一个元素，删完之后pos刚好是end的位置，end位置是没有元素的，那么pos就失效了。因此删除vector中任意位置上元素时，vs就认为该位置迭代器失效了。
我们在插入和删除时，一定要注意迭代器失效，否则会很坑。
迭代器失效的解决办法：在使用前，对迭代器重新赋值即可。
二、vector模拟实现
template<class T>
class vector
{
public:
typedef T* iterator;
typedef const T* const_iterator;
vector()
:_start(nullptr)
,_finish(nullptr)
,_end_of_shorage(nullptr)
{}
vector(size_t n, const T& val = T())
:_start(nullptr)
, _finish(nullptr)
, _end_of_shorage(nullptr)
{
_start = new T[n];
for (size_t i = 0; i < n; i++)
{
_start[i] = val;
}
_finish = _start + n;
_end_of_shorage = _start + n;
}
vector(int n, const T& val = T())
:_start(nullptr)
, _finish(nullptr)
, _end_of_shorage(nullptr)
{
_start = new T[n];
for (size_t i = 0; i < n; i++)
{
_start[i] = val;
}
_finish = _start + n;
_end_of_shorage = _start + n;
}
template<class InputIterator>
vector(InputIterator first, InputIterator last)
:_start(nullptr)
, _finish(nullptr)
, _end_of_shorage(nullptr)
{
while (first != last)
{
push_back(*first);
++first;
}
}
vector(const vector<T>& v)
:_start(nullptr)
, _finish(nullptr)
, _end_of_shorage(nullptr)
{
_start = new T[v.capacity()];
for (size_t i = 0; i < v.size(); i++)
{
_start[i] = v._start[i];
}
_finish = _start + v.size();
_end_of_shorage = _start + v.capacity();
}
void swap(vector<T>& tmp)
{
std::swap(_start, tmp._start);
std::swap(_finish, tmp._finish);
std::swap(_end_of_shorage, tmp._end_of_shorage);
}
vector<T>& operator=(vector<T> tmp)
{
swap(tmp);
return *this;
}
iterator begin()
{
return _start;
}
const_iterator begin() const
{
return _start;
}
const_iterator end() const
{
return _finish;
}
size_t size() const
{
return _finish - _start;
}
size_t capacity() const
{
return _end_of_shorage - _start;
}
T& operator[](size_t n)
{
return *(_start + n);
}
const T& operator[](size_t n) const
{
return *(_start + n);
}
void reserve(size_t n)
{
if (n > capacity())
{
T* tmp = new T[n];
size_t sz = size();
if (_start)
{
//memcpy(tmp, _start, sizeof(T) * sz);
for (size_t i = 0; i < sz; i++)
{
tmp[i] = _start[i];
}
delete[] _start;
}
_start = tmp;
_finish = _start + sz;
_end_of_shorage = _start + n;
}
}
void resize(size_t n, const T& val = T())
//T()是匿名对象，如果T是内置类型，那么c++对内置类型进行了升级，也调用默认构造。
{
if (n < size())
{
_finish = _start + n;
}
else
{
reserve(n);
while (_finish != _start + n)
{
*_finish = val;
++_finish;
}
}
}
void push_back(const T& x)
{
if (_finish == _end_of_shorage)
{
size_t newcapacity = capacity() == 0 ? 4 : capacity() * 2;
//扩容
reserve(newcapacity);
}
*_finish = x;
++_finish;
}
iterator insert(iterator pos, const T& x)
{
assert(pos <= _finish);
if (_finish == _end_of_shorage)
{
int len = pos - _start;
size_t newcapacity = capacity() == 0 ? 4 : capacity() * 2;
//扩容
reserve(newcapacity);
pos = _start + len;//修正pos,否则会迭代器失效
}
iterator end = _finish - 1;
while (end >= pos)
{
*(end + 1) = *end;
--end;
}
*(end + 1) = x;
_finish++;
return pos;
}
iterator end()
{
return _finish;
}
bool empty()
{
return _finish == _start;
}
void pop_back()
{
//erase(--end());
assert(!empty());
--_finish;
}
iterator erase(iterator pos)
{
assert(pos >= _start && pos < _finish);
iterator end = pos + 1;
while (end < _finish)
{
*(end - 1) = *end;
++end;
}
_finish--;
return pos;
}
void print(const vector<int>& v)
{
for (auto e : v)
{
cout << e << " ";
}
cout << endl;
}
~vector()
{
delete[] _start;
_start = _finish = _end_of_shorage = nullptr;
}
private:
iterator _start;
iterator _finish;
iterator _end_of_shorage;
};三、使用memcpy拷贝问题
1. memcpy是内存的二进制格式拷贝，将一段内存空间中内容原封不动的拷贝到另外一段内存空间中。
2. 如果拷贝的是自定义类型的元素，memcpy既高效又不会出错，但如果拷贝的是自定义类型元素，并且自定义类型元素中涉及到资源管理时，就会出错，因为memcpy的拷贝实际是浅拷贝。
例如：
结论：如果对象中涉及到资源管理时，千万不能使用memcpy进行对象间的拷贝，因为memcpy是浅拷贝，否则可能会引起内存泄漏甚至程序崩溃。
解决方案：T是string这样深拷贝类，调用的是string赋值运算符重载，实现string对象的深拷贝。
731
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
