Vector是什么？

• vector是C++（STL）中的一种序列容器
• Vector是一个动态数组，内存空间是连续的，支持随机访问，支持迭代器访问

Vector代码实现

变量指向

代码初始化

#include<iostream>
using namespace std;
#include<assert.h>
#include<vector>

namespace xiaofeng
{
	template<class T>
	class vector
	{
	public:
		typedef T* iterator;//迭代器
		typedef const T* const_iterator;//反向迭代器


		//初始化
		vector()
			:_start(nullptr) 
			, _finish(nullptr)
			, _end_of_storage(nullptr)
		{}

		
	private:
		iterator _start;//begin 起始位置
		iterator _finish;//end 数据结束位置
		iterator _end_of_storage;//capacity  总大小
	};

起始与结束位置

//vtor的起始位置
iterator begin()
{
    return _start;
}

//vtor的结束位置
iterator end()
{
    return _finish;
}
//反向迭代器 vtor的起始位置
const_iterator begin()const//匹配权限
{
    return _start;
}

//反向迭代器 vtor的结束位置
const_iterator end()const
{
    return _finish;
}

resize

//size  capacity都扩容
//改变整体的大小

void resize(size_t n, T val = T())//T()相当于int()   内置类型有没有构造函数 int i = int();
{
    if (n < size())
    {
        _finish = _start + n;
    }
    else
    {
        if (n > capacity()) //总体内存不够需要扩容capacity
        {
            reserve(n);
        }
        while (_finish != _start + n)//填充
        {
            *_finish = val;
            ++_finish;
        }
    }

}

reverse

//size 不变, capacity扩容
//虚拟扩容
//n==10 capacity==5
//避免扩容空间不足
void reserve(size_t n)//扩容的大小
{
    if (n > capacity())
    {
        size_t sz = size();
        T* tmp = new T[n];//可以看成模板类型初始化
        if (_start)
        {
            memcpy(tmp, _start, sizeof(T) * size());//从_start拷贝size字节到tmp  取一块新的地址
            delete[] _start;
        }
        _start = tmp;
        _finish = _start + sz;
        _end_of_storage = _start + n;
    }
}

push_back

void push_back(const T& x)//模板自动匹配类型
{

    if (_finish == _end_of_storage)
    {
        reserve(capacity() == 0 ? 4 : capacity() * 2); //判断capacity是否为空，空就==4 非空扩容两倍
    }
    *_finish = x;//插入
    ++_finish;
}

pop

void pop_back()
{
    assert(!empty());
    --_finish;
}

insert

//迭代器失效，野指针，异地扩容
iterator insert(iterator pos, const T& val)
{
    assert(pos >= _start);
    assert(pos <= _finish);

    if (_finish == _end_of_storage)
    {
        size_t len = pos - _start;//会异地扩容，因为要先记录相对位置
        reserve(capacity() == 0 ? 4 : capacity() * 2);
        pos = _start + len;
    }

    iterator end = _finish - 1;
    while (end >= pos)//向后移动一位腾出空间
    {
        *(end + 1) = end;
        --end;
    }
    *pos = val;//插入
    ++_finish; //更新size大小
    return pos;

}

erase

//头删
void erase(iterator pos)
{
    assert(pos >= _start);
    assert(pos < _finish);

    iterator start = pos + 1; //把_start后一个数据往前移动
    while (start != _finish)
    {
        *(start + 1) = *start;
        ++start;
    }
    --_finish;//设置大小

}

capacity

//计算capacity的大小
size_t capacity()const//不改变的直接用const
{
    return _end_of_storage - _start;
}

size

//计算size大小
size_t size()const
{
    return _finish - _start;
}

empty

bool empty()
{
    return  _finish == _start;
}

operator[]

T& operator[](size_t pos)
{
    assert(pos < size());
    return _start[pos];
}
const T& operator[](size_t pos)const
{
    assert(pos < size());
    return _start[pos];
}

测试用例

插入与删除

vector<int> v1;
v1.push_back(1);
v1.push_back(2);
v1.push_back(3);
v1.push_back(4);

//func(v1);
cout << "push_back()" << endl;


for (size_t i = 0; i < v1.size(); i++)
{
    cout <<  v1[i] << endl;
}

v1.pop_back();
v1.pop_back();
v1.pop_back();
v1.pop_back();
cout << "pop()"<< endl;

for (size_t i = 0; i < v1.size(); i++)
{
    cout <<  v1[i] << endl;
}

扩容

vector<int> v1;
v1.push_back(1);
v1.push_back(2);
v1.push_back(3);
v1.push_back(4);
v1.push_back(1);
v1.push_back(2);
v1.push_back(3);
v1.push_back(4);



cout <<"size:" << v1.size() << endl;
cout << "capacity:" <<v1.capacity() << endl;


v1.reserve(100);
cout << "reserve-->size:" << v1.size() << endl;
cout << "reserve-->capacity:" << v1.capacity() << endl;

v1.resize(1);
cout << "resize-->size:" << v1.size() << endl;
cout << "resize-->capacity:" << v1.capacity() << endl;

迭代器失效

std::vector<int> v1;
v1.push_back(1);
v1.push_back(2);
v1.push_back(3);
v1.push_back(4);
//v1.push_back(5);
for (auto e : v1)
{
    cout << e << " ";
}
cout << endl;

auto pos = find(v1.begin(), v1.end(), 3);
if (pos != v1.end())
{
    //v1.insert(pos, 30);
    pos = v1.insert(pos, 30);
}

for (auto e : v1)
{
    cout << e << " ";
}
cout << endl;
//迭代器失效问题
// insert以后我们认为pos失效了，不能再使用
(*pos)++;
*(pos+1)++;

for (auto e : v1)
{
    cout << e << " ";
}
cout << endl;