STL---Vector常用接口介绍及模拟实现

一. 什么是vector？

vector(向量)是一种对象实体, 能够容纳许多其他类型相同的元素, 因此又被称为容器。 与string相同, vector 同属于STL(Standard Template Library, 标准模板库)中的一种自定义的数据类型, 可以广义上认为是数组的增强版

特点：

1. vector是表示可变大小数组的序列容器，采用的连续存储空间来存储元素,可以采用下标对vector的元素进行访问

2.它的大小是可以动态改变的，而且它的大小会被容器以一种有效的方式动态增长,因此相对于数组占用了更多的存储空间。

2.与其它动态序列容器相比（deque, list and forward_list）， vector在访问元素的时候更加高效，在末尾添加和删除元素相对高效。对于其它不在末尾的删除和插入操作，效率更低。

二. vector的使用

在使用vector时需要包含头文件

#include<vector>

2.1 常用接口：

构造函数

(constructor)构造函数声明	接口说明
vector()（重点）	无参构造
vector（size_type n, const value_type& val = value_type()）	构造并初始化n个val
vector (const vector& x); （重点）	拷贝构造
vector (InputIterator first, InputIterator last);	使用迭代器进行初始化构造

iterator 的使用

iterator的使用	接口说明
begin +  end（重点）	获取第一个数据位置的iterator/const_iterator， 获取最后一个数据的下一个位置的iterator/const_iterator
rbegin + rend	获取第一个数据位置的iterator/const_iterator， 获取最后一个数据的下一个位置的iterator/const_iterator

Capacity容量

容量空间	接口说明
size	获取数据个数
capacity	获取容量大小
empty	判断是否为空
resize（重点）	改变vector的size
reserve （重点）	改变vector的capacity

增删查改

vector增删查改	接口说明
push_back（重点）	尾插
pop_back （重点）	尾删
find	查找（这个是算法模块实现，不是vector的成员接口）
insert	在position之前插入val
erase	删除position位置的数据
swap	交换两个vector的数据空间
operator[] （重点）	像数组一样访问

 2.2 功能代码演示

2.2.1 vector的构建

void test()
{
    vector<int> first;                                // 无参构造
    vector<int> second(4, 100);                       // 使用4个100构造
    vector<int> third(second.begin(), second.end());  // 使用迭代器进行初始化
    vector<int> fourth(third);                       // 拷贝构造

    //可以利用数组和迭代器初始化
    int myints[] = { 16,2,77,29 };
    vector<int> fifth(myints, myints + sizeof(myints) / sizeof(int));
    补充：C++11新语法：使用列表方式初始化
    vector<int> v{ 1, 2, 3, 4 };
}

2.2.2 vector的遍历（三种实现方法）

1.operator[ ]遍历

    //1.operator[]
    for (size_t i = 0; i < second.size(); i++)
    {
        cout << second[i] << " ";
    }
    cout << endl;

2.迭代器遍历

    //迭代器
    vector<int>::iterator it = second.begin();
    while (it != second.end())
    {
        cout << *it << " ";
        it++;
    }
    cout << endl;

3.范围for遍历

    //范围for
    for (auto e : second)
    {
        cout << e << " ";
    }
    cout << endl;

2.2.3 容量接口的使用

void test3()
{
    vector<int> second(128, 100);    

    cout << second.size() << endl;          //打印vector的大小
    cout << second.capacity() << endl;      //打印vector的容量
    cout << second.empty() << endl;         //判断vector是否为空
}

1. reisze(size_t n, const T& data = T())

该函数会改变vector的有效数据的个数，若n大于size的话，增多的元素会用data进行赋值，要注意resize在增多元素是还可能会进行扩容

2.reserve(size_t n)

改变vector的容量大小，通常用于知道vector有效数据个数，使用reserve提前扩容，减少数据增加时频繁的扩容操作

void test4()
{
    vector<int> v;
    // set some initial content:
    for (int i = 1; i < 10; i++)
        v.push_back(i);
    //将有效个数设置为5
    v.resize(5);
    for (size_t i = 0; i < v.size(); i++)
        cout << ' ' << v[i];
    cout << '\n';
    //将有效个数设置为8，多出来的元素赋值为100
    v.resize(8, 100);
    for (size_t i = 0; i < v.size(); i++)
        cout << ' ' << v[i];
    cout << '\n';
    //将有效个数设置为12，多出来的元素使用缺省值0
    v.resize(12);
    for (size_t i = 0; i < v.size(); i++)
        cout << ' ' << v[i];
    cout << '\n';
}

2.2.4 vector的默认扩容机制

void TestVectorExpand()
{
    size_t sz;
    vector<int> v;
    sz = v.capacity();
    cout << "making v grow:\n";
    for (int i = 0; i < 100; ++i)
    {
        v.push_back(i);
        if (sz != v.capacity())
        {
            sz = v.capacity();
            cout << "capacity changed: " << sz << '\n';
        }
    }
}

• 在VS下：扩容为1.5倍扩容

• 在Linux下：扩容为2倍扩容

2.2.5 vector 增删查改

// 尾插和尾删：push_back/pop_back
void TestVector4()
{
	vector<int> v;
	v.push_back(1);
	v.push_back(2);
	v.push_back(3);
	v.push_back(4);

	auto it = v.begin();
	while (it != v.end()) 
	{
		cout << *it << " ";
		++it;
	}
	cout << endl;

	v.pop_back();
	v.pop_back();

	it = v.begin();
	while (it != v.end()) 
	{
		cout << *it << " ";
		++it;
	}
	cout << endl;
}

// 任意位置插入：insert和erase，以及查找find
// 注意find不是vector自身提供的方法，是STL提供的算法
void TestVector5()
{
	// 使用列表方式初始化，C++11新语法
	vector<int> v{ 1, 2, 3, 4 };

	// 在指定位置前插入值为val的元素，比如：3之前插入30,如果没有则不插入
	// 1. 先使用find查找3所在位置
	// 注意：vector没有提供find方法，如果要查找只能使用STL提供的全局find
	auto pos = find(v.begin(), v.end(), 3);
	if (pos != v.end())
	{
		// 2. 在pos位置之前插入30
		v.insert(pos, 30);
	}

	vector<int>::iterator it = v.begin();
	while (it != v.end()) 
	{
		cout << *it << " ";
		++it;
	}
	cout << endl;

	pos = find(v.begin(), v.end(), 3);
	// 删除pos位置的数据
	v.erase(pos);

	it = v.begin();
	while (it != v.end()) {
		cout << *it << " ";
		++it;
	}
	cout << endl;
}

2.3 vector迭代器失效问题

迭代器的主要作用就是让算法能够不用关心底层数据结构，其底层实际就是一个指针，或者是对指针进行了封装，比如：vector的迭代器就是原生态指针T* 。因此迭代器失效，实际就是迭代器底层对应指针所指向的空间被销毁了，而使用一块已经被释放的空间，造成的后果是程序崩溃(即如果继续使用已经失效的迭代器，程序可能会崩溃)

1. 会引起底层空间发生变化的操作都可能会使迭代器发生失效，例如：push__back() 、insert()、resize()、reverse()、assign()等

#include <iostream>
using namespace std;
#include <vector>
int main()
{
 vector<int> v{1,2,3,4,5,6};
 
 auto it = v.begin();
 
 // 将有效元素个数增加到100个，多出的位置使用8填充，操作期间底层会扩容
 // v.resize(100, 8);
 
 // reserve的作用就是改变扩容大小但不改变有效元素个数，操作期间可能会引起底层容量改变
 // v.reserve(100);
 
 // 插入元素期间，可能会引起扩容，而导致原空间被释放
 // v.insert(v.begin(), 0);
 // v.push_back(8);
 
 // 给vector重新赋值，可能会引起底层容量改变
 v.assign(100, 8);
 
 /*
 出错原因：以上操作，都有可能会导致vector扩容，也就是说vector底层原理旧空间被释放掉，
而在打印时，it还使用的是释放之间的旧空间，在对it迭代器操作时，实际操作的是一块已经被释放的空间，而引起代码运行时崩溃。
 解决方式：在以上操作完成之后，如果想要继续通过迭代器操作vector中的元素，只需给it重新
赋值即可。
 */
  while(it != v.end())
  {
  cout<< *it << " " ;
  ++it;
  }
  cout<<endl;
  return 0;
}

2. 指定位置元素的删除操作--erase

#include <iostream>
using namespace std;
#include <vector>
int main()
{
 int a[] = { 1, 2, 3, 4 };
 vector<int> v(a, a + sizeof(a) / sizeof(int));
 // 使用find查找4所在位置的iterator
 vector<int>::iterator pos = find(v.begin(), v.end(), 4);
 // 删除pos位置的数据，导致pos迭代器失效。
 v.erase(pos);
 cout << *pos << endl; // 此处会导致非法访问
 return 0;
}

erase删除pos位置元素后，pos位置之后的元素会往前搬移，没有导致底层空间的改变，理论上讲迭代器不应该会失效，但是：如果pos刚好是最后一个元素，删完之后pos刚好是end的位置，而end位置是没有元素的，那么pos就失效了。因此删除vector中任意位置上元素时，vs就认为该位置迭代器失效了。

3. Linux下，g++编译器对迭代器失效的检测并不是非常严格，处理也没有vs下极端。

// 1. 扩容之后，迭代器已经失效了，程序虽然可以运行，但是运行结果已经不对了
int main()
{
 vector<int> v{1,2,3,4,5};
 for(size_t i = 0; i < v.size(); ++i)
 cout << v[i] << " ";
 cout << endl;
 auto it = v.begin();
 cout << "扩容之前，vector的容量为: " << v.capacity() << endl;
 // 通过reserve将底层空间设置为100，目的是为了让vector的迭代器失效 
 v.reserve(100);
 cout << "扩容之后，vector的容量为: " << v.capacity() << endl;
 
 // 经过上述reserve之后，it迭代器肯定会失效，在vs下程序就直接崩溃了，但是linux下不会 // 虽然可能运行，但是输出的结果是不对的
 while(it != v.end())
 {
 cout << *it << " ";
 ++it;
 }
 cout << endl;
 return 0;
}

程序输出：
1 2 3 4 5
扩容之前，vector的容量为: 5
扩容之后，vector的容量为: 100
0 2 3 4 5 409 1 2 3 4 5

SGI STL中，迭代器失效后，代码并不一定会崩溃，但是运行结果肯定不对，如果it不在begin和end范围内，肯定会崩溃的

2.4 模拟实现vector

#include<iostream>
#include<string.h>
#include<string>
#include<assert.h>
using namespace std;
namespace zyq
{
	template <class T>
	class vector
	{
	public:
		typedef T* iterator;
		typedef const T* const_iterator;

		vector(){}

		~vector()
		{
			delete[] _start;
			_start = _finish = _endofstorage = nullptr;
		}

		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(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);
			}
		}

		//在一些OJ题目中可以这样写 vector<int> v={1,2,3,4,5};
		//initializer_list:这个类底层其实就两个指针，用12345构造该类，然后隐式类型转换
		vector(initializer_list<T> il)
		{
			reserve(il.size());
			for (auto& e : il)
			{
				push_back(e);
			}
		}

		vector<T>& operator= (vector<T> v)
		{
			swap(v);
			return *this;
		}

		size_t size() const
		{
			return _finish - _start;
		}

		size_t capacity() const
		{
			return _endofstorage - _start;
		}

		T& operator[](size_t i)
		{
			return _start[i];
		}

		const T& operator[](size_t i) const
		{
			return _start[i];
		}

		iterator begin()
		{
			return _start;
		}

		iterator end()
		{
			return _finish;
		}

		const_iterator begin() const
		{
			return _start;
		}

		const_iterator end() const
		{
			return _finish;
		}

		void swap(vector<T>& v)
		{
			std::swap(_start, v._start);
			std::swap(_finish, v._finish);
			std::swap(_endofstorage, v._endofstorage);
		}

		void reserve(size_t n)
		{
			if (n > capacity())
			{
				iterator tmp = new T[n];
				size_t oldsize = size();
				//这里要注意不能这样写:memcpy(tmp, _start, size() * sizeof(T));
				//会造成泛型类的浅拷贝，会析构两次
				for (size_t i = 0; i < size(); i++)
				{
					tmp[i] = _start[i];
				}

				delete[] _start;
				_start = tmp;
				_finish = _start + oldsize;
				_endofstorage = _start + n;
			}
		}

		void resize(size_t n, const T& val=T())
		{
			if (n > size())
			{
				reserve(n);
				while (_finish < _start + n)
				{
					*_finish = val;
					++_finish;
				}
			}
			else
			{
				_finish = _start + n;
			}
		}

		void push_back(const T& val)
		{
			if (_finish == _endofstorage)
			{
				size_t newcapacity = capacity() == 0 ? 4 : capacity() * 2;
				reserve(newcapacity);
			}
			*_finish = val;
			_finish++;
		}

		iterator insert(iterator pos, const T& val)
		{
			assert(pos >= 0 && pos <= _finish);
			if (_finish == _endofstorage)
			{
				size_t len = pos - _start;
				size_t newcapacity = capacity() == 0 ? 4 : capacity() * 2;
				reserve(newcapacity);
				pos = _start + len;
			}
			iterator tmp = _finish - 1;
			while (tmp >= pos)
			{
				*(tmp + 1) = *tmp;
				tmp--;
			}
			*pos = val;
			_finish++;
			return pos;
		}

		iterator erase(iterator pos)
		{
			assert(pos >= 0 && pos < _finish);
			iterator tmp = pos;
			while (tmp<_finish-1)
			{
				*tmp = *(tmp+1);
				tmp++;
			}
			--_finish;
			return pos;
		}

	private:
		iterator _start=nullptr;
		iterator _finish=nullptr;
		iterator _endofstorage=nullptr;
	};

	template<class T>
	void print_vector(const vector<T>& v)
	{
		//for循环
		for (size_t i= 0; i < v.size(); i++)
		{
			cout << v[i] << " ";
		}
		cout << endl;

		//迭代器
		typename vector<T>::const_iterator it = v.begin();
		//auto it = v.begin();
		while (it != v.end())
		{
			cout << *it << " ";
			it++;
		}
		cout << endl;

		//auto
		for (auto& e : v)
		{
			cout << e << " ";
		}
		cout << endl;
	}
}