探索C++中的动态数组：实现自己的Vector容器

值得注意的是传参给了缺省值，因为存储数据可能是string这种数据，给了缺省值会去掉对应的默认构造函数，虽然内置类型没有默认构造，但是为了解决这类问题，有了类似于默认构造类处理内置类型；

void resize(size_t n,T x=T() )   
		{if (n_finish = _start + n;;
			}
			else
			{if (n > capacity())   //扩容
				{reserve(n);
				}
				for (size_t i = size(); i <= n; i++)  //尾插
				{_start[i] = x;      //可以复用push_back函数
				}
				_finish = _start + n;    //更新
			}
			
		}

6.insert函数

思路：

1.检查是否需要扩容

2.挪动数据

3.插入，更新下标

iterator insert(iterator pos, const T& x)
{assert(pos);
	assert(pos >= _start);     //断言
	assert(pos <= _finish);
	if (_finish == _endofstorage)
	{size_t len = pos - _start;              //记录之前的值
		reserve(capacity() == 0 ? 4 : 2 * capacity();    //扩容
		pos = _start + len;          //更新pos下标
	}
	//memmove(pos+1, pos, sizeof(T) * (_finish - pos));  
	iterator end = _finish-1;
	while (end>=pos)
	{*(end+1) = *end;     //拷贝
		end--;
	}
	*pos = x;     //插入
	++_finish;    
	return pos;    //返回pos位置的迭代器，防止迭代器失效问题
}

7.erase函数

直接挪动数据覆盖

iterator erase(iterator pos)
	{assert(pos < _finish && pos >= _start);   //断言
		iterator end = pos;
		while (end < _finish)
		{*end = *(end + 1);   //挪动数据覆盖
			end++;
		}
		--_finish;          //更新下标
		return pos;      //返回pos位置的迭代器，防止迭代器失效问题
	}

8.swap函数

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

9.赋值运算符重载

与上章《魔法之线：探索string类的神秘世界》链接: link赋值运算符重载方法一样；

现代写法：

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

10.拷贝构造函数

传统写法：

vector(const vector& v)
	{iterator tmp = new T[v.capacity()];
		memcpy(tmp, v._start, sizeof(T) * v.size());
		_start = tmp;
		_finish = _start + v.size();
		_endofstorage = _start + v.capacity();
	}

稍便捷的方式

直接复用尾插函数，将对象v的数据一个一个尾插；

vector(vector& v)
			:_start(nullptr)
			,_finish(nullptr)
			,_endofstorage(nullptr)
		{reserve(v.capacity());      //提前空间，减少尾插扩容
			for (const auto& e : v)
			{push_back(e);
			}
		}

11.其他简单函数的实现：

//判空
		bool empty()
		{return size();
		}
		//返回第一个数据
		T& front()const
		{return *_start;
		}
		//返回最后一个数据
		T& back()const
		{return *(_finish-1);
		}
		//返回有效数据个数
		size_t size()const
		{return _finish - _start;
		}
		//返回容量
		size_t capacity()const
		{return _endofstorage - _start;
		}
		//[]运算符重载
		T& operator[](size_t pos)
		{assert(pos>=0 && posassert(pos >= 0 && pos < size());
			return _start[pos];
		}
		iterator begin()
		{return _start;
		}
		iterator end()
		{return _finish;
		}
		const_iterator begin()const
		{return _start;
		}
		const_iterator end()const
		{return _finish;
		}
		~vector()
		{if(_start)
				delete[] _start;
			_start = _finish = _endofstorage = nullptr;
		}

💕最后希望内容对大家有所帮助😊😊😊