模拟实现vector

1.简单介绍和构造和begin 和end和push_back实现

vector没什么好介绍的，基本只要你懂string，在翻翻文档就知道vector怎么用了，如果不了解string，可以翻翻我写的string介绍和string模拟
vector前面有些代码太过简单所以就先直接放出来了

#pragma one

namespace vet
{
	template<class T>
	class vector
	{
	public:
		typedef T* iterator;
		typedef const T* const_iterator;
		vector()
			:_start(nullptr)
			, _finish(nullptr)
			, _endofstoage(nullptr)
		{

		}

		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 _endofstoage - _start;
		}

		void push_bak(const T& x)
		{
			if (_finish == _endofstoage)
			{
				size_t newcapacity = capacity() == 0 ? 4 : capacity() * 2;
				reserve(newcapacity);
			}
			*_finish = x;
			++_finish;
		}

	private:
		iterator _start;
		iterator _finish;
		iterator _endofstoage;
		
	};
}

上面的代码我们写到了push_back，原理很简单如果容量不够就扩容，如果容量刚开始为零就给四个空间，容量不为零就扩二倍
如果容量够了，就赋值。
至于push_back用引用呢？那么不如想想不用引用会怎么样？
我们学习了深度拷贝就可以知道，调用拷贝构造代价极大，里面的数据越多，代价越大。
那么搞定了push_back那么就要实现里面reserve，reserve就是负责开空间增容，但是我们不考虑缩容为什么？
因为缩容因为现在这个空间比要缩容的空间大，所以要异地扩，扩完了再释放原来的空间，这就是用时间来换空间，但是现在随着硬件越来越发达，现在都是用空间来换时间了，故而不考虑

2.reserve代码

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

上面代码的意思是容量不够扩容，先通过tmp来看看会不会扩空间失败，再给_start,里面有个操作就是if(_start)判断里面有没有内容，如果有那就拷贝下来到tmp，如果没有就不用拷贝内容，最后释放_statr的空间，再tmp赋值给_statr，而最后_finish和_endofstoage的赋值就是大小和内存都发生改变了，所以他们也要发生改变
不过上面代码会有问题
测试代码

	void test_vector1()
	{
		vector<int> v;
		v.push_back(1);
		v.push_back(2);
		v.push_back(3);
		v.push_back(4);
		v.push_back(5);

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

到底是什么问题呢？
上图片

一开始是push了一个1进入了里面空间不够扩容来到了，reserve里面但是可以看到start发生了改变，这时候就知道问题了，因为start的值被改过了，所以_finish和_endofstoage也发生了错误，所以才报错了
那么怎么解决呢？

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

这样子就没问题了

3.pop和iterator[]

代码

		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 pop_back()
		{
			if (_finish > _start)
			{
				--_finish;
			}
		}
		

检测代码

	void test_vector1()
	{
		vector<int> v;
		v.push_back(1);
		v.push_back(2);
		v.push_back(3);
		v.push_back(4);
		v.push_back(5);

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

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

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

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

可以看到上面用到了范围for，因为我们把迭代器写出来，所以范围for也可以用了

4.resize实现

有三种情况，第一种空间不够扩容，第二种直接插入字符串，第三种，缩容
代码

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

T val = T()这种写法可能觉得有点奇怪，但是为了更好的使用模板，内置函数现在也支持函数构造和析构函数
证明图片

5.insert实现

一开始肯定要检查参数合不合法，判断内存够不够，挪动数据，最后插入
代码

void insert(iterator pos, const T& x)
		{
			//检查参数
			assert(pos >= _start && pos <= _finish);

			//检查内存
			if (_finish == _endofstoage)
			{
				size_t newcapacity = capacity() == 0 ? 4 : capacity() * 2;
				reserve(newcapacity);
			}

			//挪动数据
			iterator end = _finish - 1;
			while (pos <= end)
			{
				*(end + 1) = *end;
				end--;
			}

			*pos = x;
			_finish++;
		}

运行截图

看到没有问题
但是如果你相信没有问题的话就上当啦

为什么会出现随机值，只是比之前多插入了一个参数而已
这个问题是因为迭代器失效了
为什么会失效，内存不够扩容，扩容后_start和_finish更新了，但是pos没更新啊
所以就会出现这个问题了
解决办法更新pos用算相对值的办法

		void insert(iterator pos, const T& x)
		{
			//检查参数
			assert(pos >= _start && pos <= _finish);

			//检查内存
			if (_finish == _endofstoage)
			{
				size_t n =  pos-_start;
				size_t newcapacity = capacity() == 0 ? 4 : capacity() * 2;
				reserve(newcapacity);
				pos = _start + n;
			}

			//挪动数据
			iterator end = _finish - 1;
			while (pos <= end)
			{
				*(end + 1) = *end;
				end--;
			}

			*pos = x;
			_finish++;
		}

运行结果

上面的迭代器其实是有点问题的看下面

6.insert使用，用迭代器来把偶数位前插入20

代码

void test_vector3()
	{
		// 在所有的偶数的前面插入20
		vector<int> v;
		v.push_back(1);
		v.push_back(2);
		v.push_back(3);
		v.push_back(4);
		v.push_back(5);
		v.push_back(6);

		vector<int>::iterator it = v.begin();
		while (it != v.end())
		{
			if (*it % 2 == 0)
			{
				v.insert(it, 20);
			}

			++it;
		}

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

运行了一下发现报错了

调试

可以看到了it的指针失效了，和之前的问题一样，insert扩容了，但是it没有更新
可能有人疑问前面我们不是处理了迭代器失效的问题吗？

仔细想想我们的是值传递啊，改变pos，不会影响it，这里面加引用不行的，因为加了引用有的值就传不过去了
那么我们再试试不用扩容的有没有问题

看到了也有问题，这种也算是迭代器失效，这是it不是野指针，但是it指向的位置的意义变了导致我们重复插入20
那么怎么解决呢？
代码

		iterator insert(iterator pos, const T& x)
		{
			//检查参数
			assert(pos >= _start && pos <= _finish);

			//检查内存
			if (_finish == _endofstoage)
			{
				//更新pos
				size_t n = _start - pos;
				size_t newcapacity = capacity() == 0 ? 4 : capacity() * 2;
				reserve(newcapacity);
				pos = _start + n;
			}

			//挪动数据
			iterator end = _finish - 1;
			while (pos <= end)
			{
				*(end + 1) = *end;
				end--;
			}

			*pos = x;
			_finish++;
			return pos;
		}

这个时候就用了返回值，通过可以通过接受返回值来更新it，但是记得更新的it要++，因为再2的前面插入20；返回的是20的位置，只加1次还是2的位置，所以要加++二次
在偶数前面插入20代码

	void test_vector3()
	{
		// 在所有的偶数的前面插入20
		vector<int> v;
		v.reserve(10);
		v.push_back(1);
		v.push_back(2);
		v.push_back(3);
		v.push_back(4);
		v.push_back(5);
		v.push_back(6);

		vector<int>::iterator it = v.begin();
		while (it != v.end())
		{
			if (*it % 2 == 0)
			{
				it=v.insert(it, 20);
				++it;
			}

			++it;
		}

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

运行结果

这样就没有问题了

7.erase实现

让后一位覆盖到前一位就行了
代码

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

测试代码

	void test_vector4()
	{
		vector<int> v;
		//v.reserve(10);
		v.push_back(1);
		v.push_back(2);
		v.push_back(3);
		v.push_back(4);
		cout << v.size() << ":" << v.capacity() << endl;
		auto pos = find(v.begin(), v.end(), 2);
		if (pos != v.end())
		{
			v.erase(pos);
		}

		cout << *pos << endl;
		*pos = 10;
		cout << *pos << endl << endl;

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

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

上面代码作用是找到2，删除2，并把3覆盖成10
运行结果

8.删除全部偶数位，理解erase的用法

void test_vector5()
	{
		vector<int> v;
		//v.reserve(10);
		v.push_back(1);
		v.push_back(2);
		v.push_back(3);
		v.push_back(4);
		auto it = v.begin();
		while (it != v.end())
		{
			if (*it % 2 == 0)
			{
				v.erase(it);
			}
		}
		for (auto e : v)
		{
			cout << e << " ";
		}
		cout << endl;
	}

不过相信大家看到这种写法都发现和inser一样的结果，野指针，或者是指针意义失效
简单来讲就是上面代码实现不了要求
为什么，1 2 3 4，我们要删除偶数，到2的位置删除，删除了加加1位越过了3的位置不管4，到4的位置偶数删除，删完后，又加加一位，但是_finish的位置再被删除了的4的位置，而我们erase要删除的位置在_finish+1，越界了。
正确写法应该是是偶数的删除，但是不加加，如果不是偶数就加加

	void test_vector6()
	{
		std::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())
		{
			if (*it % 2 == 0)
			{
				it = v.erase(it);
			}
			else
			{
				++it;
			}
		}

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

9.clear实现

		void clear()
		{
			_finish = _start;
		}

接下来我们来实现前面的析构函数吧

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

10.实现拷贝构造现代写法和赋值实现

我们要复用构造函数，但是string是有带参的构造，我们vector没有，其实是有的
我们还没写
因为和string模拟实现里面的差不多，直接上代码

		//这个是模板参数可以自动推演，如果你传的是string那么他就是string的类型vector就是vector的类型
		template <class InputIterator>
		vector(InputIterator first, InputIterator last)
			:_start(nullptr)
			, _finish(nullptr)
			, _endofstoage(nullptr)
		{
			while (first != last)
			{
				push_back(*first);
				++first;
			}
		}


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


		vector(const vector<T>& v)
			:_start(nullptr)
			, _finish(nullptr)
			, _endofstoage(nullptr)
		{
			vector<T> tmp(v.begin(), v.end());
			swap(tmp);
		}

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

11.n个val来初始化的构造函数

		vector(size_t n, const T& val = T())
			: _start(nullptr)
			, _finish(nullptr)
			, _endofstoage(nullptr)
		{
			reserve(n);
			for (int i = 0; i < n; ++i)
			{
				push_back(val);
			}
		}

检测代码

	void test_vector8()
	{
		vector<int> v1(10, 2);
		for (auto e : v1)
		{
			cout << e << " ";
		}
		cout << endl;
	}

结果报错了？
我们再试试其他案例

发现又没有问题，这里其实就是匹配问题了
有问题了那个是匹配到了

至于为什么会匹配到是，因为我们错误的案例传的是二个int参数，而我们实现的n个val初始化里面的n是size_t，所以它就没有匹配到
解决方法
写个函数重载，有一个版本的n改成int

		vector(int n, const T& val = T())
			: _start(nullptr)
			, _finish(nullptr)
			, _endofstoage(nullptr)
		{
			reserve(n);
			for (int i = 0; i < n; ++i)
			{
				push_back(val);
			}
		}

		vector(size_t n, const T& val = T())
			: _start(nullptr)
			, _finish(nullptr)
			, _endofstoage(nullptr)
		{
			reserve(n);
			for (int i = 0; i < n; ++i)
			{
				push_back(val);
			}
		}

运行结果

12.用vector打印杨辉三角

代码

class Solution {
public:
	vector<vector<int>> generate(int numRows) {
		vector<vector<int>> vv;
		vv.resize(numRows);
		for (size_t i = 0; i < vv.size(); ++i)
		{
			// 杨辉三角，每行个数依次递增
			vv[i].resize(i + 1, 0);

			// 第一个和最后一个初始化成1
			vv[i][0] = 1;
			vv[i][vv[i].size() - 1] = 1;
		}

		for (size_t i = 0; i < vv.size(); ++i)
		{
			for (size_t j = 0; j < vv[i].size(); ++j)
			{
				if (vv[i][j] == 0)
				{
					// 中间位置等于上一行j-1 和 j个相加
					vv[i][j] = vv[i - 1][j - 1] + vv[i - 1][j];
				}
			}
		}

		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;

		return vv;
	}
};

void test_vector8()
{
	vector<vector<int>> ret = Solution().generate(5);

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

打印结果

可以看到报错了
至于为什么前面杨辉三角打印成功了，是因为他返回vector里面打印的，是用来发现错误的代码，下面那串错的，才是错误示范，问题其实是关系深浅拷贝的问题

这是一个浅拷贝，memcpy那个位置要拷贝的不是int是vector，而且因为这个是浅拷贝，把而且它不是数组它是vector，所以释放会调用析构函数，所以他会全部释放，所以他们是野指针
下面图片是调用析构函数的_start

可以看到都是随机值
总结：string//vector等等，当T涉及深浅拷贝的类型时，我们们扩容使用memcpy是存在浅拷贝问题的
解决也很简单，把他变成深拷贝就行了

		void reserve(size_t n)
		{
			size_t sz = size();
			if (n > capacity())
			{
				T* tmp = new T[n];
				if (_start)
				{
					//memcpy(tmp, _start, size() * sizeof(T));
					for (size_t i = 0; i < size(); i++)
					{
						tmp[i] = _start[i];
					}
					delete[] _start;
				}
				_start = tmp;
			}
			_finish = _start + sz;
			_endofstoage = _start + n;
		}

打印结果

13.模拟实现全部vector代码包含测试用例

#pragma once

namespace vet
{
	template<class T>
	class vector
	{
	public:
		typedef T* iterator;
		typedef const T* const_iterator;
		vector()
			:_start(nullptr)
			, _finish(nullptr)
			, _endofstoage(nullptr)
		{

		}

		//这个是模板参数可以自动推演，如果你传的是string那么他就是string的类型vector就是vector的类型
		template <class InputIterator>
		vector(InputIterator first, InputIterator last)
			:_start(nullptr)
			, _finish(nullptr)
			, _endofstoage(nullptr)
		{
			while (first != last)
			{
				push_back(*first);
				++first;
			}
		}

		vector(int n, const T& val = T())
			: _start(nullptr)
			, _finish(nullptr)
			, _endofstoage(nullptr)
		{
			reserve(n);
			for (int i = 0; i < n; ++i)
			{
				push_back(val);
			}
		}

		vector(size_t n, const T& val = T())
			: _start(nullptr)
			, _finish(nullptr)
			, _endofstoage(nullptr)
		{
			reserve(n);
			for (int i = 0; i < n; ++i)
			{
				push_back(val);
			}
		}

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


		vector(const vector<T>& v)
			:_start(nullptr)
			, _finish(nullptr)
			, _endofstoage(nullptr)
		{
			vector<T> tmp(v.begin(), v.end());
			swap(tmp);
		}

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

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

		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 _endofstoage - _start;
		}

		void reserve(size_t n)
		{
			size_t sz = size();
			if (n > capacity())
			{
				T* tmp = new T[n];
				if (_start)
				{
					//memcpy(tmp, _start, size() * sizeof(T));
					for (size_t i = 0; i < size(); i++)
					{
						tmp[i] = _start[i];
					}
					delete[] _start;
				}
				_start = tmp;
			}
			_finish = _start + sz;
			_endofstoage = _start + n;
		}


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

		iterator insert(iterator pos, const T& x)
		{
			//检查参数
			assert(pos >= _start && pos <= _finish);

			//检查内存
			if (_finish == _endofstoage)
			{
				//更新pos
				size_t n =  pos-_start;
				size_t newcapacity = capacity() == 0 ? 4 : capacity() * 2;
				reserve(newcapacity);
				pos = _start + n;
			}

			//挪动数据
			iterator end = _finish - 1;
			while (pos <= end)
			{
				*(end + 1) = *end;
				end--;
			}

			*pos = x;
			_finish++;
			return pos;
		}

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

		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 pop_back()
		{
	/*		if (_finish > _start)
			{
				--_finish;
			}*/
			erase(end() - 1);
		}

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

			insert(end(), x);
		}

		void clear()
		{
			_finish = _start;
		}

	private:
		iterator _start;
		iterator _finish;
		iterator _endofstoage;	
	};
	void test_vector1()
	{
		vector<int> v;
		v.push_back(1);
		v.push_back(2);
		v.push_back(3);
		v.push_back(4);
		v.push_back(5);

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

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

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

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

		// C++中内置类型也可以认为有构造函数 析构函数
        // 这样才能更好支持模板
        // void resize(size_t n, T val = T())
		int i = 0;
		int j = int();
		int k = int(1);
	}

	void test_vector2()
	{
		/*vector<int> v;
		v.resize(10, -1);

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

		v.insert(v.begin(), 0);

		for (auto e : v)
		{
			cout << e << " ";
		}
		cout << endl;
	}
	void test_vector3()
	{
		// 在所有的偶数的前面插入20
		vector<int> v;
		v.reserve(10);
		v.push_back(1);
		v.push_back(2);
		v.push_back(3);
		v.push_back(4);
		v.push_back(5);
		v.push_back(6);

		vector<int>::iterator it = v.begin();
		while (it != v.end())
		{
			if (*it % 2 == 0)
			{
				it=v.insert(it, 20);
				++it;
			}

			++it;
		}

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

	void test_vector4()
	{
		vector<int> v;
		//v.reserve(10);
		v.push_back(1);
		v.push_back(2);
		v.push_back(3);
		v.push_back(4);
		cout << v.size() << ":" << v.capacity() << endl;
		auto pos = find(v.begin(), v.end(), 2);
		if (pos != v.end())
		{
			v.erase(pos);
		}

		cout << *pos << endl;
		*pos = 10;
		cout << *pos << endl << endl;

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

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

	void test_vector5()
	{
		vector<int> v;
		//v.reserve(10);
		v.push_back(1);
		v.push_back(2);
		v.push_back(3);
		v.push_back(4);
		auto it = v.begin();
		while (it != v.end())
		{
			if (*it % 2 == 0)
			{
				v.erase(it);
			}
		}
		for (auto e : v)
		{
			cout << e << " ";
		}
		cout << endl;
	}

	void test_vector6()
	{
		std::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())
		{
			if (*it % 2 == 0)
			{
				it = v.erase(it);
			}
			else
			{
				++it;
			}
		}

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

	void test_vector7()
	{
		vector<int> v;
		v.push_back(1);
		v.push_back(2);
		v.push_back(3);
		v.push_back(4);
		v.push_back(5);

		vector<int> v1(v.begin(), v.end());
		std::string s("hello");
		vector<int> v2(s.begin(), s.end());

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

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

		vector<int> v3(v);
		for (auto e : v3)
		{
			cout << e << " ";
		}
		cout << endl;

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

	void test_vector8()
	{
		vector<int> v1(10, 2);
		for (auto e : v1)
		{
			cout << e << " ";
		}
		cout << endl;
	}

	class Solution {
	public:
		vector<vector<int>> generate(int numRows) {
			vector<vector<int>> vv;
			vv.resize(numRows);
			for (size_t i = 0; i < vv.size(); ++i)
			{
				// 杨辉三角，每行个数依次递增
				vv[i].resize(i + 1, 0);

				// 第一个和最后一个初始化成1
				vv[i][0] = 1;
				vv[i][vv[i].size() - 1] = 1;
			}

			for (size_t i = 0; i < vv.size(); ++i)
			{
				for (size_t j = 0; j < vv[i].size(); ++j)
				{
					if (vv[i][j] == 0)
					{
						// 中间位置等于上一行j-1 和 j个相加
						vv[i][j] = vv[i - 1][j - 1] + vv[i - 1][j];
					}
				}
			}

			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;

			return vv;
		}
	};

	void test_vector9()
	{
		vector<vector<int>> ret = Solution().generate(5);

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