顺序链表的模板化

通过数据结构，学习到了如何在用c语言的方式实现顺序链表，我们可以定义typedef int Detatype,使得我们在更换数据类型时候变得方便。但是我们的顺序链表并不能同时适应多种类型的调试，因此我们可以将顺序链表包装成一个模板，完成这种操作。

template<class T>
//顺序链表在类里面基本封装完成初始化，增删，判容
class SeqList
{
public:
	SeqList(int capacity = 3)
		: _pData(new T[capacity])
		, _capacity(capacity)
		, _size(0)
	{}


	// SeqList(const SeqList<T>& s);
	// SeqList<T>& operator=(const SeqList<T>& s)

	void PushBack(const T& data)
	{
		_CheckCapacity();
		_pData[_size++] = data;
	}

	void PopBack()
	{
		if (_size)
			--_size;
	}

	// void Insert(size_t pos, const T& data);
	// void Erase(size_t pos);

	T& Front()
	{
		return _pData[0];
	}

	const T& Front()const
	{
		return _pData[0];
	}

	T& Back()
	{
		return _pData[_size - 1];
	}

	const T& Back()const
	{
		return _pData[_size - 1];
	}

	T& operator[](size_t index)
	{
		assert(index < _size);
		return _pData[index];
	}

	const T& operator[](size_t index)const
	{
		assert(index < _size);
		return _pData[index];
	}

	size_t Size()const
	{
		return _size;
	}

	size_t Capacity()const
	{
		return _capacity;
	}

	bool Empty()const
	{
		return 0 == _size;
	}

	// 将顺序表中的有效元素清空
	void Clear()
	{
		_size = 0;
	}

	~SeqList();

private:
	void _CheckCapacity()
	{
		if (_size == _capacity)
		{
			size_t newCapacity = (_capacity << 1);
			
			// 申请空间
			T* pTemp = new T[newCapacity];

			// 拷贝元素
			memcpy(pTemp, _pData, _size*sizeof(T));

			// 释放旧空间
			delete[] _pData;
			_pData = pTemp;
			_capacity = newCapacity;
		}
	}
private:
	T* _pData;
	size_t _capacity;
	size_t _size;
};

通过把顺序链表的基本操作设置为public,我们可以通过函数全局调用在类外设置调用析构函数。

template<class T>
SeqList<T>::~SeqList()
{
	if (_pData)
	{
		delete[] _pData;
		_pData = nullptr;
		_capacity = 0;
		_size = 0;
	}
}

插入数据，删除数据，检验大小，进行顺序链表的基本操作

void TestSeqList()
{
	SeqList<int> s1;   // class SeqList<int>
	const SeqList<double> s2;  // class SeqList<double>
	//SeqList<char> s3;    // class SeqList<char>

	s1.PushBack(1);
	s1.PushBack(2);
	s1.PushBack(3);
	s1.PushBack(4);
	s1[0] = 10;
	cout << s1.Size() << endl;
	cout << s1.Front() << endl;
	cout << s1.Back() << endl;
	s1.Clear();
	cout << s1.Size() << endl;

	//s2.PushBack(1.0);
	cout << s2[0] << endl;
	//s2[0] = 2.0;
}
int main()
{
	TestSeqList();
	return 0;
}