动态数组的模拟实现以及部分算法的实现和迭代器的封装支持范围for

#include<iostream>
#include<memory>
using namespace std;
namespace my {

	template<class T>
	class Seqlist {
	    public:
			typedef T* iterator;//数组支持指针访问，因此直接对原型指针进行封装
		public:
			//构造函数，提供默认容量，用户也可以自行提供
		Seqlist(const size_t& capacity=10)
			:_array(new T[sizeof(T) * capacity])
			,_capacity(capacity)
			, _size(0)
		{}

		//重载[]运算符
		T& operator[](const size_t& pos){
			return _array[pos];
		}

		//尾插
		void push_back(const T& data) {
			if (Is_full()) {//判断数组中是否已满，如果满了则进行扩容操作
				change_capacity();
			}
			_array[_size] = data;
			_size++;
		}
		//获取数组存储元素个数
		size_t Getsize() {
			return _size;
		}
		//获取数组容量
		size_t Getcapacity() {
			return _capacity;
		}
		//头插
		void push_front(const T& data) {
			if (Is_full()) {
				change_capacity();
			}
			for (int i = Getsize(); i > 0; i--) {
				_array[i] = _array[i - 1];
			}
			_array[0] = data;
			_size++;
		}
		//按位置插入
		void push_pos(const size_t& pos,const T& data) {
			if (Is_full()) {
				change_capacity();
			}
			for (int i = Getsize(); i >= pos; i--) {
				_array[i] = _array[i - 1];
			}
			_array[pos - 1] = data;
			_size++;

		}
		//尾删，不需要删除数组元素，只需要访问不到此数据即可
		void pop_back() {
			_size--;
		}
		//头删，依次向前覆盖
		void pop_front() {
			for (int i = 0; i < Getsize(); i++) {
				_array[i] = _array[i + 1];
			}
			_size--;
		}
		//按位置查找，
		T& find_pos(const size_t pos) {
			if (pos>0 && pos<=Getsize())
				 return _array[pos - 1];
		}
		//按值查找
		size_t find_val(const T& data) {
			for (int i = 0; i < Getsize(); i++) {
				if (_array[i] == data) {
					return (i + 1);
				}
			}
			return -1;
		}
		//按位置删除
		void pop_pos(const size_t& pos) {
			if (pos > 0 && pos <= Getsize()) {
				for (int i = pos - 1; i < Getsize(); i++) {
					_array[i] = _array[i + 1];
				}
			}
			_size--;
		}
		//打印数组
		void Show_List() {
			for (int i = 0; i < Getsize(); i++) {
				cout << _array[i] << " ";
			}
		}
		//封装迭代器
		iterator begin() {
			return (iterator)_array;
		}
		iterator end() {
			return (iterator)(_array+_size);
		}
		//冒泡排序
		void bubbing_sort() {
			for (int i = 0; i < Getsize(); i++) {
				for (int j = i + 1; j < Getsize(); j++) {
					if (_array[i] < _array[j]) {
						std::swap(_array[i], _array[j]);
					}
				}
			}
		}
		//根据位置修改数据
		void modifica_pos(const size_t& pos, const T& data) {
			if (pos > 0 && pos <= Getsize())
			     _array[pos - 1] = data;
	    }
		//修改数组中所有值为desc的数据
		void modifica_val_all(const T& desc, const T& data) {
			for (int i = 0; i < Getsize(); i++) {
				if (_array[i] == desc) {
					_array[i] = data;
				}
			}
		}
		//判空
		bool Is_empty() {
			return _size == 0;
		}
		//判满
		bool Is_full() {
			return _size == _capacity;
		}
		//清空数组
		~Seqlist()
		{
			delete[] _array;
			_array = nullptr;
			_capacity = _size = 0;
		}

	private:
		T* _array;
		size_t _capacity;
		size_t _size;
	private:
		//修改数组容量
		void change_capacity() {
			T* new_array = new T[sizeof(T) * _capacity * 2];
			memmove(new_array, _array, sizeof(T) * _capacity);
			delete[] _array;
			_array = new_array;
			_capacity = _capacity * 2;
		}

	};
}