【C++】Array 动态数组类的设计

前言

今天学习了类模板的知识，趁热打铁写了一个动态数组类，有插入、删除、构造等成员函数（和STL实现稍有不同），恳请大家批评指正！

class Array - 类定义

template<class T>
class Array
{
private:
	T *_list;
	size_t _maxsize;
	size_t _size;
	
public:
	Array(LL __sz = 50);
	Array(const Array<T> &__a);
	Array(const vector<T> &__v);
	~Array();
	
	Array<T>& operator = (const Array<T> &__rhs);
	T& operator [] (LL __n);
	const T& operator [] (LL __n) const;
	operator T*();
	operator const T*() const;
	
	T* begin() const;
	T* end() const;
	
	size_t size() const;
	size_t max_size() const;
	T* data() const;
	
	void resize(LL __sz);
	void clear();
	void assign(T *__begin, T *__end);
	
	void push_back(const T &__a);
	T pop_back();
	void insert(LL __pos, const T &__a);
	T erase(LL __pos);
	void erase(LL __first, LL __last);
};

Array::Array(LL __sz) - 长度构造函数（默认）

template<class T> Array<T>::Array(LL __sz)
{
	assert(__sz >= 0);
	_maxsize = (size_t)(__sz);
	_size = 0;
	_list = new T[_maxsize]{};
}

Array::Array(const vector<T> &__v) - vector构造数组

template<class T> Array<T>::Array(const vector<T> &__v)
{
	_maxsize = (size_t)(__v.size());
	_size = 0;
	_list = new T[_maxsize]{};
	auto it = __v.begin();
	for (; it!=__v.end(); it++)
		push_back(*it);
}

Array::Array(const Array<T> &__a) - 拷贝构造

因为涉及到动态指针的问题，我们要自己写深拷贝来解决。

template<class T> Array<T>::Array(const Array<T> &__a)
{
	*this = __a;    //利用了重载的 = 运算符
}

Array::~Array() - 析构函数

template<class T> Array<T>::~Array()
{
	if (_list != nullptr)
		delete[] _list;
}

 Array<T>& Array::operator = (const Array<T> &__rhs) - 重载赋值运算符

template<class T> Array<T>& Array<T>::operator = (const Array<T> &__rhs)
{
	if (&__rhs != this)
	{
		if (_maxsize != __rhs._maxsize)
		{
			delete[](_list);
			_size = __rhs._size;
			_maxsize = __rhs._maxsize;
			_list = new T[_maxsize]{};
		}
		for (size_t i=0; i<_maxsize; i++)
			_list[i] = __rhs._list[i];
	}
	return *this;
}

T& Array<T>::operator [] (LL __n) - 重载下标运算符

template<class T> T& Array<T>::operator [] (LL __n)
{
	assert(__n>=0 && __n<_maxsize);
	return _list[(size_t)(__n)];
}

const T& Array<T>::operator [] (LL __n) - 重载下标运算符（常量版）

template<class T> const T& Array<T>::operator [] (LL __n) const
{
	assert(__n>=0 && __n<_maxsize);
	return _list[(size_t)(__n)];
}

Array<T>::operator T* () - 重载类型转换运算符

这样数组名就可以当作数组的首地址指针来使用。

template<class T> Array<T>::operator T* ()
{
	return _list;
}

Array<T>::operator const T* () - 重载类型转换运算符（常量版）

template<class T> Array<T>::operator const T* () const
{
	return _list;
}

T* Array<T>::begin() - 获取首指针

模仿了STL的迭代器操作，但这里返回的单纯只是指针。 

template<class T> T* Array<T>::begin() const
{
	return _list;
}

T* Array<T>::end() - 获取尾指针

模仿了STL的迭代器操作，但这里返回的单纯只是指针。

template<class T> T* Array<T>::end() const
{
	return _list + _size;
}

size_t Array<T>::size() - 返回数组元素个数

template<class T> size_t Array<T>::size() const
{
	return _size;
}

size_t Array<T>::max_size() - 返回数组最大长度

template<class T> size_t Array<T>::max_size() const
{
	return _maxsize;
}

T* Array<T>::data() - 返回底层数组的首指针

template<class T> T* Array<T>::data() const
{
	return _list;
}

void Array<T>::resize(LL __sz) - 调整数组长度

template<class T> void Array<T>::resize(LL __sz)
{
	assert(__sz >= 0);
	if ((size_t)(__sz) == _maxsize)
		return ;
	T *newL = new T[__sz]{};
	LL len = min(size_t(__sz), _maxsize);
	for (LL i=0; i<len; i++)
	{
		newL[i] = _list[i];
	}
	delete[] _list;
	_list = newL;
	_maxsize = (size_t)(__sz);
	_size = min(size_t(__sz), _size);
}

结语

Array动态数组类的分享就到这里啦！更多精彩内容请移步专栏~

掰掰ヾ(•ω•`)o