1.vector的介绍及使用
1. vector是表示可变大小数组的序列容器。
2. 就像数组一样，vector也采用的连续存储空间来存储元素。也就是意味着可以采用下标对vector的元素进行访问，和数组一样高效。但是又不像数组，它的大小是可以动态改变的，而且它的大小会被容器自动处理。
3. 本质讲，vector使用动态分配数组来存储它的元素。当新元素插入时候，这个数组需要被重新分配大小为了增加存储空间。其做法是，分配一个新的数组，然后将全部元素移到这个数组。就时间而言，这是一个相对代价高的任务，因为每当一个新的元素加入到容器的时候，vector并不会每次都重新分配大小。
4. vector分配空间策略：vector会分配一些额外的空间以适应可能的增长，因为存储空间比实际需要的存储空间更大。不同的库采用不同的策略权衡空间的使用和重新分配。但是无论如何，重新分配都应该是对数增长的间隔大小，以至于在末尾插入一个元素的时候是在常数时间的复杂度完成的。
5. 因此，vector占用了更多的存储空间，为了获得管理存储空间的能力，并且以一种有效的方式动态增长。
6. 与其它动态序列容器相比（deque, list and forward_list）， vector在访问元素的时候更加高效，在末尾添加和删除元素相对高效。对于其它不在末尾的删除和插入操作，效率更低。比起list和forward_list统一的迭代器和引用更好
2 vector的使用
2.1 vector的定义
圈起来的是经常使用的
2.2 vector iterator 的使用
2.3 vector 空间增长问题
capacity的代码在vs和g++下分别运行会发现，vs下capacity是按1.5倍增长的，g++是按2倍增长的。这个问题经常会考察，不要固化的认为，vector增容都是2倍，具体增长多少是根据具体的需求定义的。vs是PJ版本STL，g++是SGI版本STL。
reserve只负责开辟空间，如果确定知道需要用多少空间，reserve可以缓解vector增容的代价缺陷问题。
resize在开空间的同时还会进行初始化，影响size
2.4 vector 迭代器失效问题。
迭代器的主要作用就是让算法能够不用关心底层数据结构，其底层实际就是一个指针，或者是对指针进行了封装，比如：vector的迭代器就是原生态指针T* 。因此迭代器失效，实际就是迭代器底层对应指针所指向的空间被销毁了，而使用一块已经被释放的空间，造成的后果是程序崩溃(即如果继续使用已经失效的迭代器，程序可能会崩溃)。
对于vector可能会导致其迭代器失效的操作有：
1. 会引起其底层空间改变的操作，都有可能是迭代器失效，比如：resize、reserve、insert、assign、push_back等。
2. 指定位置元素的删除操作--erase
erase删除pos位置元素后，pos位置之后的元素会往前搬移，没有导致底层空间的改变，理论上讲迭代器不应该会失效，但是：如果pos刚好是最后一个元素，删完之后pos刚好是end的位置，而end位置是没有元素的，那么pos就失效了。因此删除vector中任意位置上元素时，vs就认为该位置迭代器失效了
3. 与vector类似，string在插入+扩容操作+erase之后，迭代器也会失效
3.vector深度剖析及模拟实现
1.vector模拟实现
#pragma once
#include <assert.h>
#include <iostream>
using namespace std;
namespace WJY
{
template<class T>
class vector
{
public:
typedef T* iterator;
typedef const T* const_iterator;
void swap(vector<T>& t)
{
std::swap(_start, t._start);
std::swap(_finish, t._finish);
std::swap(_endofstorage, t._endofstorage);
}
vector()
: _start(nullptr)
, _finish(nullptr)
, _endofstorage(nullptr)
{}
vector(size_t n, const T& val = T())
{
reserve(n);
for (size_t i = 0; i < n; i++)
{
push_back(val);
}
}
vector(int n, const T& val = T())
{
reserve(n);
for (int i = 0; i < n; i++)
{
push_back(val);
}
}
vector(const vector<T>& v)
{
reserve(v.capacity());
for (auto& e : v)
{
push_back(e);
}
}
template <class InputIterator>
vector(InputIterator first, InputIterator last)
{
while (first != last)
{
push_back(*first);
++first;
}
}
~vector()
{
delete[] _start;
_start = _finish = _endofstorage = nullptr;
}
vector<T> operator=(vector<T> tmp)
{
swap(tmp);
return *this;
}
//Iterators
iterator begin()
{
return _start;
}
iterator end()
{
return _finish;
}
const const_iterator begin() const
{
return _start;
}
const const_iterator end() const
{
return _finish;
}
//Capacity
size_t size() const
{
return _finish - _start;
}
size_t capacity() const
{
return size_t(_endofstorage - begin());
}
bool empty() const
{
return begin() == end();
}
void resize(size_t n)
{
resize(n, T());
}
void resize(size_t new_size, const T& x) {
if (new_size < size())
erase(begin() + new_size, end());
else
insert(end(), new_size - size(), x);
}
void reserve(size_t n)
{
if (n > capacity())
{
size_t sz = size();
T* tmp = new T[n + 1];
if (_start)
{
for (size_t i = 0; i < size(); i++)
{
tmp[i] = _start[i];
}
delete[] _start;
}
_start = tmp;
_finish = _start + sz;
_endofstorage = _start + n;
}
}
//Element access
T& operator[](size_t pos)
{
assert(pos < size());
return _start[pos];
}
const T& operator[](size_t n) const
{
assert(n < size());
return _start[n];
}
//Modifiers
void insert(iterator pos, const T& x)
{
assert(pos >= _start);
assert(pos <= _finish);
if (_finish == _endofstorage)
{
size_t len = pos - _start;
reserve(capacity() == 0 ? 4 : capacity() * 2);
pos = _start + len;
}
iterator end = _finish;
while (end > pos)
{
*(end) = *(end - 1);
-- end;
}
*pos = x;
++ _finish;
}
void push_back(const T& x)
{
insert(end(), x);
}
iterator erase(iterator position)
{
assert(position >= _start);
assert(position < _finish);
iterator end = position;
while (end != _finish)
{
*(end) = *(end + 1);
++ end;
}
-- _finish;
return position;
}
void clear()
{
//erase(begin(), end());
_finish = _start;
}
private:
iterator _start = nullptr;
iterator _finish = nullptr;
iterator _endofstorage = nullptr;
};
void test1()
{
vector<int> a;
for (size_t i = 0; i < 100; i++)
{
a.insert(a.begin(), i+1);
}
a.insert(a.end(), 0);
for (size_t i = 0; i < a.size(); i++)
{
cout << a[i] << " ";
}
}
void test2()
{
vector<int> a;
for (size_t i = 0; i < 10; i++)
{
a.insert(a.begin(), i + 1);
}
for (size_t i = 0; i < a.size(); i++)
{
cout << a[i] << " ";
}
cout << endl;
for (size_t i = 0; i < 10; i++)
{
a.erase(a.begin());
}
for (size_t i = 0; i < a.size(); i++)
{
cout << a[i] << " ";
}
/*cout << endl;
vector<int> b(a);
for (size_t i = 0; i < a.size(); i++)
{
cout << a[i] << " ";
}
cout << endl;
vector<int> c;
c = b;
for (size_t i = 0; i < a.size(); i++)
{
cout << a[i] << " ";
}
cout << endl;*/
}
void test3()
{
vector<int> a;
for (size_t i = 0; i < 20; i++)
{
a.insert(a.begin(), i + 1);
}
for (size_t i = 0; i < a.size(); i++)
{
cout << a[i] << " ";
}
a.clear();
cout << endl;
for (size_t i = 0; i < 20; i++)
{
a.insert(a.begin(), i + 1);
}
for (size_t i = 0; i < a.size(); i++)
{
cout << a[i] << " ";
}
a.clear();
cout << endl;
for (size_t i = 0; i < 20; i++)
{
a.insert(a.begin(), i + 1);
}
for (size_t i = 0; i < a.size(); i++)
{
cout << a[i] << " ";
}
}
}
2.深浅拷贝问题
1. memcpy是内存的二进制格式拷贝，将一段内存空间中内容原封不动的拷贝到另外一段内存空间中
2. 如果拷贝的是自定义类型的元素，memcpy既高效又不会出错，但如果拷贝的是自定义类型元素，并且自定义类型元素中涉及到资源管理时，就会出错，因为memcpy的拷贝实际是浅拷贝。
如果对象中涉及到资源管理时，千万不能使用memcpy进行对象之间的拷贝，因为memcpy是
浅拷贝，否则可能会引起内存泄漏甚至程序崩溃
3.其他问题
1.判断区间问题
在erase()，insert(),中记得判断所给的position是否越界
2.const迭代器问题
在编写begin(),end() 的const对象时，得在定义一个const_iterator，总共就有两个const存在了，const_iterator是防止对象的值被修改，返回const是为了防止指针指向的地址被改变
3.现代写法的拷贝构造函数
vector<T> operator=(vector<T> tmp)
{
swap(tmp);
return *this;
}值得学习
4.带有简单空间配置器的vector模拟
template<typename T>
class Allocator
{
public:
T* allocate(size_t size) //开辟内存
{
return (T*)malloc(size);
}
void deallocate(void* ptr) //释放内存
{
free(ptr);
}
void construct(T* ptr,const T& val) //构造对象
{
new (ptr) T(val); //使用定位new在已经存在的ptr上构造新对象
}
void destory(T* ptr) //释放对象
{
ptr->~T();
}
};
template<class T,typename allocator = Allocator<T>>
class vector
{
public:
typedef T* iterator;
vector(int size = 0)
{
if (size == 0)
{
_start = nullptr;
_finish = nullptr;
_endofstorage = nullptr;
}
else
{
_start = mAllocator.allocate(size * sizeof(T));
_finish = _start;
_endofstorage = _start + size;
}
}
vector(int size, const T& val)
{
if (size == 0)
{
_start = nullptr;
_finish = nullptr;
_endofstorage = nullptr;
}
else
{
_start = mAllocator.allocate(size * sizeof(T));
for (int i = 0; i < size; ++i)
{
mAllocator.construct(_start + i, val);
}
_finish = _endofstorage = _start + size;
}
}
vector(iterator _first, iterator _last)
{
_start = mAllocator.allocate(_last - _first);
for (int i = 0; i < _last - _first; ++i)
{
mAllocator.construct(_start + i, *(_start + i));
}
_finish = _endofstorage = _start + (_last - _first);
}
void resize()
{
if (_start == nullptr)
{
_start = mAllocator.allocate(sizeof(T));
_finish = _start;
_endofstorage = _start + 1;
}
else
{
int offset = _endofstorage - _start;
T* newdata = mAllocator.allocate((_endofstorage - _start) * 2);
int i = 0;
while (_start != _endofstorage)
{
mAllocator.construct(newdata + i, *(_start));
++i;
mAllocator.destory(_start);
++_start;
}
mAllocator.deallocate(_start);
_start = newdata;
_finish = _start + offset;
_endofstorage = _start + 2 * offset;
}
}
iterator insert(iterator it, const T& val)
{
//first last end
if (_finish == _endofstorage)
{
int offset = it - _start;
resize();
it = _start + offset;
}
T* tmp = _finish;//最后一个元素的后继地址
while (tmp != it)
{
mAllocator.construct(tmp, *(tmp - 1));
--tmp;
mAllocator.destory(tmp);
}
mAllocator.construct(tmp, val);
++_finish;
}
void push_back(const T& val)
{
if (full())
resize();
mAllocator.construct(_finish++, val); //追求效率，没有复用
}
void pop_back()
{
if (empty())
return;
--_finish;
mAllocator.destroy(_finish);
}
bool full()const
{
return _finish == _endofstorage;
}
bool empty()const
{
return _finish == _start;
}
int size()const
{
return (_finish - _start) / sizeof(T);
}
~vector()
{
}
private:
iterator _start = nullptr;
iterator _finish = nullptr;
iterator _endofstorage = nullptr;
allocator mAllocator;
};空间配置器
从STL的角度看，空间配置器是一个很常见的东西，他以缺省的形式隐藏在一切组件中，默默无闻，为各个容器高效的管理空间(空间的申请与回收)
两个代码有什么不同？
一个是简写，另一个也是简写。
其实在我们第一个代码的时候遇到了一些问题：
- 从容器中删除元素时，意思是删除了容器末尾的对象A，但是并没有调用A对象的析构函数，如果A对象占用了外部资源，那么资源的释放代码肯定在A的析构函数里面，这样就造成了资源泄露的问题。
现在都通过空间配置器allocator解决了，仔细对比最开始的Vector和修改后带空间配置器版本的Vector的代码实现，体会allocator在容器中的具体使用。
7026
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
