C++：vector的介绍及其模拟实现

基本介绍

• C++标准库类模板vector是一种更加健全的数组替代品，它它提供了很多C风格的基于指针的数组所没有的能力
• 在默认情况下，一个整型vector对象的所有元素都被设置为0
• 可以用vector<数据类型>名称 (大小);形式的声明来定义一个能够存储任何数据类型的vector对象
• 类模板vector的成员函数size返回调用它的vector对象的元素个数
• 使用方括号[]可以访问或修改vector的元素的值
• 标准类模板vector的对象可以直接用相等运算符==和不等运算符!=进行比较。vector对象也可以直接使用赋值运算符

vector内置函数介绍（C++11）

成员函数

void Test1()  //成员函数
{
	//构造函数
	// constructors used in the same order as described above:
	vector<int> first;                                // empty vector of ints
	vector<int> second(4, 100);                       // four ints with value 100
	vector<int> third(second.begin(), second.end());  // iterating through second
	vector<int> fourth(third);                       // a copy of third

	// the iterator constructor can also be used to construct from arrays:
	int myints[] = { 16,2,77,29 };
	vector<int> fifth(myints, myints + sizeof(myints) / sizeof(int));

	cout << "The contents of fifth are:";
	for (vector<int>::iterator it = fifth.begin(); it != fifth.end(); ++it)
		cout << ' ' << *it;
	cout << endl;


	//赋值运算符重载
	vector<int> f(3, 0);
	vector<int> b(5, 0);

	b = f;
	f = std::vector<int>();

	cout << "Size of foo: " << int(f.size()) << endl;
	cout << "Size of bar: " << int(b.size()) << endl;
}

迭代器

void Test2()
{
	vector<int> v;
	for (int i = 1; i <= 5; i++)
	{
		v.push_back(i);
	}

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

	int i = 0;

	vector<int>::reverse_iterator rit = v.rbegin();
	for (; rit != v.rend(); ++rit)
		*rit = ++i;

	cout << "myvector contains:";
	for (vector<int>::iterator it = v.begin(); it != v.end(); ++it)
		cout << ' ' << *it;
	cout << endl;
	//cbegin,cend,crbegin,crend属于C++11转悠
}

容量

void Test3()
{
	vector<int> v;
	for (int i = 1; i <= 5; i++)
	{
		v.push_back(i);
	}

	cout << "v.size():" << v.size() << endl;
	cout << "v.capacity():" << v.capacity() << endl;
	cout << "v.max_size():" << v.max_size() << endl;

	v.resize(10);
	//修改v的有效元素个数，若入参小于原size则，截取原来v的前入参个，大于可用指定字符进行填充
	v.reserve(10);
	//修改v的底层空间，不改变有效元素
	v.empty();
	//判断v是否为空
}

元素存取

void Test5()
{
	vector<int> v{ 1,2,3,4,5,6,7 };
	//运算符[]
	cout << v[3] << endl;
	//at函数
	cout << v.at(3) << endl;
	//对于[]和at来说：
	//[]：通过assert来判断越界错误
	//at：内部通过异常机制来检测是否越界

	//front：第一个元素
	cout << v.front() << endl;

	//back：最后一个元素
	cout << v.back() << endl;

	//data：返回一个指向内部使用的内存数组的直接指针
	//C++11专用
	cout << v.data() << endl;
}

修改

void Test4()
{
	vector<int> v;
	for (int i = 1; i <= 5; i++)
	{
		v.push_back(i);
	}
	//push_back：在v的尾部进行插入

	v.pop_back();
	//在v的尾部删除一个元素

	auto it = v.begin();
	v.insert(it, 2, 4);
	//插入元素

	v.erase(it);
	//删除元素

	vector<int> v2{ 7,6,5,4,3 };
	swap(v, v2);
	//交换两个vector对象

	v.clear();
	//情况vector对象
}

模拟实现

#pragma once

#include <assert.h>
namespace bite
{
	template<class T>
	class vector
	{
	public:
		typedef T* iterator;

	public:
		vector()
			:start(nullptr)
			, finish(nullptr)
			, end_of_stroage(nullptr)
		{
			//	构造函数
		}

		vector(int n, const T& data = T())
			:start(new T(n))
			, finish(start + n)
			, end_of_stroage(finish)
		{
			//memset(start,data,n);   全部设置为0可以，该函数使用字节来初始化
			for (int i = 0; i < n; i++)
			{
				start[i] = data;
			}
		}

		template<class Iterator>
		vector(Iterator first, Iterator last)   //区间构造
		{
//			distance(first, last);  //两个迭代器之间的距离，即相隔了多少个元素
			auto it = first;
			size_t count = 0;
			while (it != last)
			{
				count++;
				it++;
			}
			start = new T[count];
			finish = start;
			end_of_stroage = start + count;
			it = first;
			while (it != last)
			{
				*finish++ = *it++;
			}
		}

		vector(const vector<T>& v)  //拷贝构造
		{
			start = new T[v.capacity()];
			finish = start + v.size();
			end_of_stroage = start + v.capacity();
			for (size_t i = 0; i < v.size(); i++)
			{
				start[i] = v[i];
			}
		}

		
		//迭代器
		iterator begin()
		{
			return start;
		}

		iterator end()
		{
			return finish;
		}

		iterator rbegin()
		{
			return end();
		}

		iterator rend()
		{
			return begin();
		}

		//
		//容量
		size_t size()const
		{
			return finish - start;
		}

		size_t capacity()const
		{
			return end_of_stroage - start;
		}

		bool empty()const
		{
			return start == finish;
		}

		void resize(size_t newsize, const T& data = T())
		{
			size_t oldsize = size();
			if (newsize > oldsize)
			{
				if (newsize > capacity())
				{
					reserve(newsize);
				}
				for (size_t i = oldsize; i < newsize; i++)
				{
					start[i] = data;
				}
			}
			finish = start + newsize;
		}

		void reserve(size_t newcapacity)
		{
			size_t oldcapacity = capacity();
			if (newcapacity > oldcapacity)
			{
				T* temp = new T[newcapacity];
				memcpy(temp, start, sizeof(T) * oldcapacity);
				delete[] start;
				size_t count = size();
				start = temp;
				finish = start + count;
				end_of_stroage = start + newcapacity;
			}
		}

		//
		//元素访问
		T& operator[](size_t index)
		{
			assert(index < size());
			return start[index];
		}

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

		T& front()
		{
			return *start;
		}

		T& front()const
		{
			return *start;
		}

		T& back()
		{
			return *(finish - 1);
		}

		T& back()const
		{
			return *(finish - 1);
		}

		///
		//元素修改
		void push_back(const T& data)
		{
			if (size() != 0 && size() == capacity())
			{
				reserve(capacity() * 2);
			}

			*finish++ = data;
		}

		void pop_back()
		{
			if (empty())
			{
				return;
			}
			--finish;
		}

		iterator insert(iterator pos, const T& data)
		{}
		iterator erase(iterator pos)
		{
			auto posnext = pos + 1;
			auto ret = pos;
			while (posnext != finish)
			{
				*pos++ = *posnext++;
			}
			finish--;
			return ret;
		}
		iterator erase(iterator first, iterator last)
		{
			finish = start; //内置
		}
		void clear()
		{
			erase(begin(), end());
		}

		//void swap(vector<T>& v)
		//{
		//	std::swap(start, v.start);
		//	std::swap(finish, v.finish);
		//	std::swap(end_of_stroage, v.end_of_stroage);
		//}


	private:
		iterator start;
		iterator finish;
		iterator end_of_stroage;
	};
}

#include <iostream>
using namespace std;
void Test1()
{
	bite::vector<int> v1;        //空的
	bite::vector<int> v2(10, 5); //10个值为5的元素

	int array[] = { 1,2,3,4,5 };
//	bite::vector<int> v3(array, array + sizeof(array) / sizeof(array[0]));
	bite::vector<int> v4(v2);

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

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

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