前言

上篇博客介绍了voctor的大部分的重要接口，本篇博客将模拟实现部分接口的效果。

vector的模拟实现

vector的模拟实现分为两个文件进行实现：vector.h、test.cpp

• vector.h

该部分为文件的主要部分，分别实现了vector的以下功能（思路）：
1）begin()、end()以及const begin()、 const end()。 直接返回_start和_finish即可。
2）size。_finish和_start两个指针的差，即为数据的大小。
3）capacity。_end_of_storage和_start两个指针的差，即为容量的大小。
4）reserve。判断是否需要扩容，需要则进行扩容，注意迭代器失效问题。
5）empty。判断_start和_finish是否相等，相等则为空。
6）push_back。首先判断是否需要扩容，然后再将数据进行插入。
7）pop_back。直接将_finish减少一个即可，下次插入时，下一个数据会被覆盖。
8）insert。判断是否需要扩容，接着将数据往后挪，再将新的数据进行插入。
9）operator[]。判断是否会超出vector的范围，若在范围内则直接进行输出即可。

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

namespace vector_by_self
{
	template<class T>
	class vector
	{
	public:
		typedef T* iterator;
		typedef const T* const_iterator;
		
		iterator begin()
		{
			return _start;
		}

		iterator end()
		{
			return _finish;
		}

		const_iterator begin() const
		{
			return _start;
		}

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

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

		void reserve(size_t x)
		{
			if (x > capacity())
			{
				size_t oldsize = size();
				T* tmp = new T[x];
				memcpy(tmp, _start, sizeof(T) * oldsize);
				delete[] _start;
				_start = tmp;
				_finish = oldsize + tmp;
				_end_of_storage = x+tmp;
			}
		}

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

		void push_bcak(const T& x)
		{
			if (_finish == _end_of_storage)
			{
				reserve(capacity() == 0 ? 4 : capacity() * 2);
			}
			*_finish = x;
			_finish++;
		}

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

		iterator insert(iterator pos, const T& x)
		{
			if (_finish == _end_of_storage)
			{
				size_t tmp = pos - _start;
				reserve(capacity() == 0 ? 4 : capacity()*2);
				pos = _start + tmp;
			}
			iterator end = _finish-1;
			while(end >= pos)
			{
				*(end + 1) = *end;
				end--;
			}
			*pos = x;
			_finish++;
			return pos;
		}

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

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

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

	template<class T>
	void vector_print(const vector<T> v)
	{
		//typename vector<T>::const_iterator it = v.begin();
		auto it = v.begin();
		while (it != v.end())
		{
			cout << *it << " ";
			it++;
		}
		cout << endl;
	}

	void vector_test1()
	{
		vector<int> v;
		v.push_bcak(1);
		v.push_bcak(2);
		v.push_bcak(3);
		v.push_bcak(4);
		v.push_bcak(5);
		v.push_bcak(6);

		vector_print(v);
		cout << v.size() << endl;
		cout << v.capacity() << endl;

		v.pop_back();
		vector_print(v);

		v.insert(v.begin(), 9);
		vector_print(v);
	}
}

• test.cpp

#include"vector.h"

int main()
{
	vector_by_self::vector_test1();
	return 0;
}

vector的oj题

只出现一次的数字

只出现一次的数字-力扣

class Solution {
public:
    int singleNumber(vector<int>& nums) {
        int once=0;
        for(auto i:nums)
        {
            once ^= i;
        }
        return once;
    }
};

杨辉三角

杨辉三角-力扣

思路：

1. 利用vector实现二维数组的效果，将值都初始化成1
2. 从第三层开始将中间的数字进行计算

class Solution {
public:
    vector<vector<int>> generate(int numRows) 
    {
        vector<vector<int>> vv(numRows);
        for(int i=0;i<numRows;i++)
        {
            vv[i].resize(i+1,1);
        }
        for(int i=2;i<numRows;i++)
        {
            for(int j=1;j<i;j++)
            {
                vv[i][j]=vv[i-1][j]+vv[i-1][j-1];
            }
        }
    return vv;
    }
};