自定义动态数组模板类

成员函数声明

#pragma once
#ifndef ARRAY_H
#define ARRAY_H

template <class T>
class Array {
private:

	T* list;
	int size;

public:
	Array(int sz = 50);

	Array(const Array<T>& a);

	~Array();

	// 不返回引用会创建一个新对象,造成资源浪费
	Array<T>& operator=(const Array<T>& a);

	T& operator[](int pos);

	// 提供给常对象的读取函数
	const T& operator[](int pos) const;

	T* operator* ();

	const T* operator* () const;
	int getsize() const;

	void resize(int sz);
};

#endif ARRAY_H

成员函数实现

#include "Array.h"
#include<cassert>
using namespace std;
template<class T>
Array<T>::Array(int sz)
{
	assert(sz >= 0);
	size = sz;
	list = new T[size];
}

template<class T>
Array<T>::~Array()
{
	delete[] list;
}

template<class T>
 Array<T>::Array(const Array<T>& a)
{
	 size = a.size;
	 list = new T[size];
	 for (int i = 0; i < size; i++)
	 {
		 list[i] = a.list[i];
	 }
}

template <class T>
Array<T>& Array<T>::operator=(const Array<T>& a)
{
	if (&a != this) {
		if (this->size != a.size) {
			delete[] list;
			size = a.size;
			list = new T[size];	
		}
		for (int i = 0; i < size; i++)
		{
			list[i] = a.list[i];
		}
	}
	return *this;
}

template <class T>
T& Array<T>::operator[](int pos)
{
	assert(pos >= 0 && pos < size);
	return list[pos];
}

template <class T>
const T& Array<T>::operator[](int pos) const
{
	assert(pos >= 0 && pos < size);
	return list[pos];
}

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

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

template <class T>
int Array<T>::getsize() const
{
	return size;
}

template <class T>
void Array<T>::resize(int sz)
{
	assert(sz >= 0);
	if (sz == size) return;
	T* newlist = new T[sz];
	int n = sz < size ? sz : size;
	for (int i = 0; i < n; i++)
	{
		newlist[i] = list[i];
	}
	delete[] list;
	list = newlist;
	size = sz;
}