C++容器 简单Vector实现

抽象类

    template<typename T>
	class linearList
	{
	public:
		virtual bool empty() = 0;
		virtual int size() = 0;
		virtual bool erase(const int index) = 0;
		virtual void insert(const int index, T element) = 0;
		virtual void clear() = 0;
	};

实体类

#include"linearList.h"
#include<stdlib.h>
#include<iostream>

#define BASIC_SIZE 16            //基础容器容量

	//=====================================DECLARE=====================================
	template<typename T>
	class vector :public linearList<T>
	{
	private:
		T *List = nullptr;       //数组头指针

		int SIZE = 0;            //存放的元素数量
		int CAPACITY = 0;        //容器尺寸

	private:
		inline bool capacityNotEnough();
		inline bool capacityExcessive();
		inline bool wrongIndex(const int index);

		void increaseCapacity();							   //扩容
		void decreaseCapacity();							   //减容
		void initialization();								   //初始化
	public:
		vector();
		vector(const vector& object);						   //拷贝构造函数
		~vector();

		void push_back(T elelemente);                          //尾部插入元素
		bool pop_back();									   //移除尾部元素
		T front();											   //获取头部元素
		T back();											   //获取尾部元素

		T& operator[](const int index);                        //[]操作符重载
		T& operator=(const T& object);                         //=操作符重载

		template<typename T>
		friend std::ostream& operator<<(std::ostream& os, const vector<T>& object);	//重载输出

		int size() override final;                             //返回元素数量
		int capacity() override final;						   //返回容器大小
		bool empty() override final;                           //是否为空
		bool erase(const int index) override final;            //删除指定位置的元素
		void insert(const int index, T element) override final;//插入元素到指定位置
		void clear() override final;                           //清空
	};

详细实现

//=====================================DEFINE=====================================
	template<typename T>
	inline bool vector<T>::capacityNotEnough()
	{
		return (SIZE >= CAPACITY);
	}

	template<typename T>
	inline bool vector<T>::capacityExcessive()
	{
		return ((CAPACITY > BASIC_SIZE) && (SIZE <= (CAPACITY >> 2)));
	}

	template<typename T>
	inline bool vector<T>::wrongIndex(const int index)
	{
		return (index < 0 || index >= SIZE || index >= CAPACITY);
	}
    //============扩容=============
	template<typename T>
	void DataStructure::vector<T>::increaseCapacity()
	{
		T* newList = new T[CAPACITY << 1];                  //容量翻倍
		std::copy(List, List + SIZE, newList);				//拷贝
		delete[] List;
		List = newList;
		newList = nullptr;
		CAPACITY <<= 1;
	}
    //============减容=============
	template<typename T>
	void vector<T>::decreaseCapacity()
	{
		T* newList = new T[CAPACITY >> 1];					//容量减半
		std::copy(List, List + SIZE, newList);				//拷贝
		delete[] List;
		List = newList;
		newList = nullptr;
		CAPACITY >>= 1;
	}
    //============初始化=============
	template<typename T>
	void vector<T>::initialization()
	{
		List = new T[BASIC_SIZE];
		CAPACITY = BASIC_SIZE;
		SIZE = 0;
	}
    //============构造函数=============
	template<typename T>
	DataStructure::vector<T>::vector()
	{
		initialization();
	}
    //============拷贝构造函数=============
	template<typename T>
	vector<T>::vector(const vector & object)
	{
		this->SIZE = object.SIZE;
		this->CAPACITY = object.CAPACITY;
		this->List = new T[object.CAPACITY];
		std::copy(object.List, object.List + object.SIZE, this->List);
	}
    //============析构函数=============
	template<typename T>
	DataStructure::vector<T>::~vector()
	{
		if (!List)	delete[] List;
	}
    //============尾插=============
	template<typename T>
	void DataStructure::vector<T>::push_back(T elelemente)
	{
		if (capacityNotEnough())	increaseCapacity();

		List[SIZE] = elelemente;
		SIZE++;
	}
    //============去尾=============
	template<typename T>
	bool vector<T>::pop_back()
	{
		if (SIZE > 0)
		{
			SIZE--;
			return true;
		}

		return false;
	}
    //============头元素=============
	template<typename T>
	T vector<T>::front()
	{
		if (SIZE > 0)	return T(List[0]);

		return T();
	}
    //============尾元素=============
	template<typename T>
	T vector<T>::back()
	{
		if (SIZE > 0)	return T(List[SIZE - 1]);

		return T();
	}
    //============是否为空=============
	template<typename T>
	bool DataStructure::vector<T>::empty()
	{
		return (SIZE == 0);
	}
    //============元素数量=============
	template<typename T>
	int DataStructure::vector<T>::size()
	{
		return SIZE;
	}
    //============容量=============
	template<typename T>
	int vector<T>::capacity()
	{
		return CAPACITY;
	}
    //============删除元素=============
	template<typename T>
	bool DataStructure::vector<T>::erase(int index)
	{
		if (wrongIndex(index))	return false;

		std::copy(List + index + 1, List + SIZE, List + index);
		SIZE--;

		if (capacityExcessive())	decreaseCapacity();
		return true;
	}
    //============插入元素=============
	template<typename T>
	void DataStructure::vector<T>::insert(int index, T element)
	{
		if (capacityNotEnough())	increaseCapacity();

		std::copy(List + index, List + SIZE, List + index + 1);
		List[index] = element;
		SIZE++;
	}
    //============清空=============
	template<typename T>
	void vector<T>::clear()
	{
		delete[] List;
		List = nullptr;
		initialization();	
	}
    //============重载[]=============
	template<typename T>
	T & DataStructure::vector<T>::operator[](const int index)
	{
		if (wrongIndex(index))
		{
			this->~vector();
			std::abort();
		}

		return List[index];
	}
    //============重载赋值=============
	template<typename T>
	T & vector<T>::operator=(const T& object)
	{
		if (this != &object)	this = object;

		return *this;
	}

	//=====================================FUNCTION=====================================
    //============重载<<=============
	template<typename T>
	std::ostream & operator<<(std::ostream & os, const vector<T>& object)
	{
		for (int index = 0; index < object.SIZE - 1; index++)
			os << object.List[index] << ",";
	
		os << object.List[object.SIZE - 1];

		return os;
	}