目录
大框架
为了与库里实现的更接近一些，先来看一下STL中是如何实现vector的（这里不是PJ版，PJ版稍微晦涩一点不容易理解，这里采用Linux下g++的版本）这里仅就大体框架做个简单介绍，其中复杂的概念不做过多解释。
首先是vector定义的模板参数T和Alloc，这是空间配置器是一种底层实现机制，使用角度不用管。
可以看到源码做了很多typedef，主要是对格式的控制和方便理解编写。其中将T* typedef成了iterator，这个要注意，后面protected 成员变量会用到。
这里成员变量就用到了刚刚typedef的iterator，实际上就是T* start ; T* finish; T* end_of_storage;
T就是实例化模板参数。好像与我们设想的变量不太一样，我们设想的应该是有size和capacity的，但是这里全部统一使用指针，其实只是改变了使用方式，本质还是一样的。
假设存在size（有效数据个数），capacity（容量），那么finish也可以表示成start+size，end_of_storage也可以表示成strat+capacity，本质是一样的。
后面是各个接口的实现，后面我们自己实现的时候具体说明，先把大框架搭建起来。
namespace bc
{
template<class T>
class vector
{
public:
typedef T* iterator;
private:
iterator _start;
iterator _finish;
iterator _end_of_storage;
};
}为了避免和库里的冲突，将我们的实现代码封在命名空间内，库里的繁杂的typedef我们省略，只保留基本的T* 的重命名和成员变量表示。
接口实现
vector.h
#pragma once
#include<iostream>
#include<vector>
#include<assert.h>
using namespace std;
namespace bc
{
template<class T>
class vector
{
public:
typedef T* iterator;
vector()
:_start(nullptr)
, _finish(nullptr)
, _end_of_storage(nullptr)
{ }
//拷贝构造写法一
//vector(const vector<T>& v)
// : _start(nullptr)
// , _finish(nullptr)
// , _end_of_storage(nullptr)
//{
// reserve(size());
// for (auto& e : v) {
// push_back(e);
// }
//}
//拷贝构造现代写法
template<class InputIterator>
vector(InputIterator first, InputIterator last)
: _start(nullptr)
, _finish(nullptr)
, _end_of_storage(nullptr)
{
while (first != last) {
push_back(*first);
first++;
}
}
vector(vector<T>& v)
: _start(nullptr)
, _finish(nullptr)
, _end_of_storage(nullptr)
{
vector<T> tmp(v.begin(), v.end());
swap(tmp);
}
vector(size_t n, const T& val= T())
: _start(nullptr)
, _finish(nullptr)
, _end_of_storage(nullptr)
{
reserve(n);
for (size_t i = 0; i < n; ++i) {
push_back(val);
}
}
//函数重载
vector(int n, const T& val= T())
: _start(nullptr)
, _finish(nullptr)
, _end_of_storage(nullptr)
{
reserve(n);
for (int i = 0; i < n; ++i) {
push_back(val);
}
}
~vector() {
delete[]_start;
_start = _finish = _end_of_storage = nullptr;
}
vector<T>& operator=(vector<T> v) {
swap(v);
return *this;
}
size_t size()const {
return _finish - _start;
}
size_t capacity()const {
return _end_of_storage - _start;
}
iterator begin() {
return _start;
}
iterator end() {
return _finish;
}
const iterator begin() const {
return _start;
}
const iterator end() const {
return _finish;
}
bool empty()const {
return _finish == _start;
}
void clear() {
_finish = _start;
}
void swap(vector<T>& v) {
std::swap(_start, v._start);
std::swap(_finish, v._finish);
std::swap(_end_of_storage, v._end_of_storage);
}
T& operator[](size_t pos) {
assert(pos < size());
return _start[pos];
}
const T& operator[](size_t pos) const {
assert(pos < size());
return _start[pos];
}
void resize(size_t n, T val = T()) {
if (n > capacity()) {
reserve(n);
}
if (n > size() && n <= capacity()) {
while (_finish < _start + n) {
*_finish = val;
++_finish;
}
}
if (n <= size()) {
_finish = _start + n;
}
}
void reserve(size_t n) {
if (n > capacity()) {
size_t oldsize = size();
T* tmp = new T[n];
if (_start != nullptr) {
memcpy(tmp, _start, sizeof(T) * oldsize);
/*for (size_t i = 0; i < oldsize; ++i) {
tmp[i] = _start[i];
}*/
delete[]_start;
}
_start = tmp;
_finish = tmp + oldsize;
_end_of_storage = _start + n;
}
}
void push_back(const T& x) {
if (_finish == _end_of_storage) {
size_t newcapacity = capacity() == 0 ? 4 : 2 * capacity();
reserve(newcapacity);
}
*_finish = x;
++_finish;
}
void pop_back() {
assert(!empty());
_finish--;
}
//迭代器失效
iterator insert(iterator pos, const T& x) {
assert(pos >= _start);
assert(pos < _finish);
if (_finish == _end_of_storage) {
size_t len = pos - _start;
size_t newcapacity = capacity() == 0 ? 4 : 2 * capacity();
reserve(newcapacity);
pos = _start + len;
}
iterator end = _finish - 1;
while (end >= pos) {
*(end + 1) = *(end);
--end;
}
*pos = x;
_finish++;
return pos;
}
iterator erase(iterator pos) {
assert(pos >= _start);
assert(pos < _finish);
iterator begin = pos + 1;
while (begin < _finish) {
*(begin-1) = *(begin);
++begin;
}
_finish--;
return pos;
}
private:
iterator _start;
iterator _finish;
iterator _end_of_storage;
};下面是我给出的测试用例：
vector.h
void Test1() {
vector<int>a;
a.push_back(1);
a.push_back(1);
a.push_back(1);
a.push_back(1);
a.push_back(1);
cout << a.capacity() << endl;
for (size_t i = 0; i < a.size(); ++i)
{
cout << a[i] << " ";
}
cout << endl;
vector<int>::iterator it = a.begin();
while (it != a.end()) {
cout << (*it) << " ";
it++;
}
cout << endl;
//a.resize(2);
for (auto e : a) {
cout << e << " ";
}
cout << endl;
cout << a.empty() << endl;
a.pop_back();
for (auto e : a) {
cout << e << " ";
}
cout << endl;
}
void Test2() {
vector<int> a;
a.push_back(1);
a.push_back(1);
a.push_back(1);
a.push_back(1);
for (auto e : a) {
cout << e << " ";
}
cout << endl;
a.insert(a.begin(), 0);
for (auto e : a) {
cout << e << " ";
}
cout << endl;
vector<int>::iterator it = find(a.begin(), a.end(), 1);
if (it != a.end()) {
a.insert(it, 2);
}
for (auto e : a) {
cout << e << " ";
}
cout << endl;
(*it)++;
for (auto e : a) {
cout << e << " ";
}
cout << endl;
}
void Test3() {
vector<int> v;
v.push_back(1);
v.push_back(2);
v.push_back(3);
v.push_back(4);
v.push_back(4);
v.push_back(5);
vector<int>::iterator it = v.begin();
while (it != v.end()) {
if ((*it) % 2 == 0) {
it = v.erase(it);
}
else {
++it;
}
}
for (auto e : v) {
cout << e << " ";
}
cout << endl;
}
void Test4() {
vector<int> v;
v.push_back(1);
v.push_back(1);
v.push_back(1);
v.push_back(1);
vector<int> a(v);
for (auto e : a) {
cout << e << " ";
}
cout << endl;
vector<int> b;
b = a;
for (auto e : b) {
cout << e << " ";
}
cout << endl;
vector<int>c(10, 1);
for (auto e : c) {
cout << e << " ";
}
cout << endl;
}
void Test5()
{
vector<vector<int>> vv;
vector<int> v(4, 1);
vv.push_back(v);
vv.push_back(v);
vv.push_back(v);
vv.push_back(v);
vv.push_back(v);
for (size_t i = 0; i < vv.size(); ++i)
{
for (size_t j = 0; j < vv[i].size(); ++j)
{
cout << vv[i][j] << " ";
}
cout << endl;
}
cout << endl;
}
}test.cpp
#include"vector.h"
int main()
{
bc::Test1();
bc::Test2();
bc::Test3();
bc::Test4();
bc::Test5();
/*vector<int> v;
v.push_back(1);
v.push_back(2);
v.push_back(3);
v.push_back(4);
v.push_back(5);
std::vector<int>::iterator it = v.begin();
while (it != v.end()) {
if ((*it) % 2 == 0) {
v.erase(it);
}
++it;
}
for (auto e : v) {
cout << e << " ";
}
cout << endl;*/
return 0;
}以上是常用接口的大致实现，基本功能包含在内，还有些不太常用的接口没有实现。
深层次拷贝问题（两次深拷贝）
在测试vector<vector<int>>二维数组的时候，发现一个奇怪的现象：
当创建好vector<vector<int>> vv模型，并创建出内置数组vector<int> v (4,1)后，此时想要设定行数，也就是通过push_back插入行实现时，如果插入4个以内，没有问题，超过4个就会报错。
由此我们可以判定问题出在扩容上，具体我画图来解释。
对于vector<vector<int>>模型要有一定理解，外部的大类型是vector<>，< >里面的类型是vector<int>，所以先从内部开始创建，vector<int> v(4,1) 构造一个{1,1,1,1}的一维数组，里面构建好了，在外面通过push_back插入，相当于插入一个一个这样的一维数组，这样就构建了二维数组，push_back多少次就相当于有多少行，里面4相当于列。
vector<int> v 数组里面的元素是int类型的，外面通过_start 指针指向v数组，指针是int* 类型的，一个指针指向一个v数组，外面还有一个_start指针指向整个vector<vector<int>>，指针类型是vector<int>*
建好二维数组后来看扩容问题，当调用reserve时，需要开辟新空间tmp，用memcpy将数据传给tmp 。 
而memcpy是按内存将数据拷贝给tmp的，这里的拷贝是浅拷贝，这就会导致一个问题，tmp最后也会指向_start 空间，
然后memcpy结束就是delete[]_start，delete会调用析构函数将_start空间释放，这下tmp指向的空间get不到了，tmp就是野指针了。
所以要想解决这个问题，就要解决内层浅拷贝的问题，将其改为深拷贝，这样外层tmp对象深拷贝，里层tmp数据也进行深拷贝，就不会出问题了。
解决方案：1、不用memcpy，利用operator = 重载函数将数据一个一个拷贝给tmp
void reserve(size_t n)
{
if (n > capacity())
{
size_t oldSize = size();
T* tmp = new T[n];
if (_start)
{
//memcpy(tmp, _start, sizeof(T)*oldSize);
for (size_t i = 0; i < oldSize; ++i)
{
tmp[i] = _start[i];
}
delete[] _start;
}
_start = tmp;
_finish = tmp + oldSize;
_endofstorage = _start + n;
}
}tmp[i] = _start[i] 将_start[i] 一个一个拷贝给tmp[i]，这里调用operator= 是深拷贝。
vector<T>& operator=(vector<T> v)
{
swap(v);
return *this;
}但是这种方法缺点是效率太低。在C++11 中会有更好的方式解决上述问题。
以上就是深层拷贝的内容，关于底层实现还有其他不同版本，但因为复杂度等原因我们是按Linux g++使用的库实现的，感谢浏览！
744
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
