C++类模板实现顺序表SeqList

main函数

#include<iostream>
#include<stdlib.h>
#include"SeqList.cpp"

using namespace std;

typedef int ElementType;
int main(void)
{
	SeqList< ElementType, 10> SeqList(1);
	cout << SeqList.ListLength() << endl;
	bool result;
	int* item = NULL;
	item = (int*)malloc(sizeof(int));
	for (int i = 0; i <5; i++)
	{
		*item = i;
		result = SeqList.AppendElement(item);
		
		if (result == false)
		{
			cout << "数据插入失败" << endl;
			break;
		}
	}
	cout << SeqList.ListLength() << endl;
	cout << "查找3位置的元素:" ;
	cout << SeqList.GetElement(3, item);
	cout << "在位置3插入元素9" << endl;
	int num = 9;
	int* itemdata = &num;
	SeqList.InsertElement(itemdata, 3);
	SeqList.GetElement(3, item);
	cout << "删除插入元素" << endl;
	int* deletElement = NULL;
	deletElement = (int *)malloc(sizeof(int));
	SeqList.DeleteElement(3, deletElement);
	cout << "遍历顺序表" << endl;
	SeqList.TraverseList();
	return 0;
}

SeqList主函数

#include"SeqList.h"

#pragma region 类构造函数
template<typename T,int MaxSize>
SeqList<T, MaxSize>::SeqList(int i)
{
	/*初始化链表的最大容量*/
	this->m_capacity = MaxSize;
	/*初始化链表的长度为0*/
	this->m_length = 0;
	/*创建包含capacity容量的T类型的
	初始化存放顺序表元素的数组*/
	this->m_data_pointer = new T[this->m_capacity];
};
#pragma endregion
#pragma region 类析构函数
template<typename T,int MaxSize>
//析构函数是释放顺序表中data的指针域申请的内存 指向null
SeqList<T,MaxSize>::~SeqList()
{
	delete[] this->m_data_pointer;
	this->m_data_pointer = NULL;//不能指向野指针，所以需要指向null
};
#pragma endregion
#pragma region 清空链表
template <typename T,int MaxSize>
void SeqList<T, MaxSize>::ClearList()
{
	this->m_length = 0;
}
#pragma endregion
#pragma region 判断链表是否为空
template<typename T,int MaxSize>
bool SeqList<T, MaxSize>::IsEmpty()
{
	if (this->m_length==0)
	{
		return true;
	}
	return false;
}
#pragma endregion
#pragma region 获取SeqList长度
template<typename T,int MaxSize>
int SeqList<T, MaxSize>::ListLength()
{
	return this->m_length;
}
#pragma endregion
#pragma region 查找指定下标的元素
//先判断顺序表是否存在，且 i 是否在合理范围内；然后再将 m_pDataArr[i] 的值赋值给元素 e。
template<typename T,int MaxSize>
bool SeqList<T,MaxSize>:: GetElement(int pos, T* item)
{
	if ((this->m_data_pointer == NULL )|| (pos<0)||(pos>this->m_capacity))
	{
		return false;
	}
	/*当前链表的数据指针域非空*/
	*item = *(this->m_data_pointer + pos);
	cout << *item << endl;
	return true;
}
#pragma endregion
#pragma region 按值查找，求顺序表中值为item的元素序号
template <typename T,int MaxSize>
int SeqList<T, MaxSize>::LoateElement(const T* item)
{
	if (item == NULL)
	{
		return -1;
	}
	T* current = NULL;
	int currentPoint = 0;
	while (currentPoint<this->m_length)
	{
		current = this->m_data_pointer + currentPoint;
		if (*item == *current )
		{
			cout << "查找到元素item:" << *item << "的位置为：" << currentPoint << endl;
			return currentPoint;
		}
		currentPoint++;
	}
	return -1;
}
#pragma endregion
#pragma region 查找元素的前驱元素
template<typename T,int MaxSize>
bool SeqList<T, MaxSize>::PriorElement(const T* current, T* prior)
{
	int pos = this->LoateElement(current);
	if (pos == -1)
	{
		return false;
	}
	else if (pos == 0)
	{
		cout << "位置为0的元素无前驱元素" << endl;
		return false;
	}
	*prior = *(this->m_data_pointer + pos - 1);
	if (prior != NULL)
	{
		return true;
	}
}
#pragma endregion
#pragma region 查找current元素的后继元素
template<typename T,int MaxSize>
bool SeqList<T, MaxSize>::NextElement(const T* current, T* next)
{
	int pos = this->LoateElement(current);
	if (pos == -1 || pos == this->m_length - 1)
	{
		return false;
	}
	*next = *(this->m_data_pointer + pos + 1);
	if (next != NULL)
	{
		return true;
	}
}
#pragma endregion
#pragma region 遍历线性表输出元素
template <typename T,int MaxSize>
void SeqList<T, MaxSize>::TraverseList()
{
	T* temp = NULL;
	if (this->m_data_pointer== NULL)
	{
		cout << "顺序表的数据域为空" << endl;
	}
	for (int i = 0; i < this->m_length; i++)
	{
		temp = this->m_data_pointer + i;
		cout << "当前第" << i << "位置的数据值为：" << *temp << endl;
	}
	return;
}
#pragma endregion
#pragma region 在指定位置插入元素
template<typename T,int MaxSize>
int SeqList<T, MaxSize>::InsertElement(T* item, int pos)
{
	if (this->m_length >= this->m_capacity)
	{
		cout << "顺序表存储空间已经满了" << endl;
		return -1;
	}
	if (pos>this->m_capacity)
	{
		pos = this->m_length;
		cout << "已经将pos位置修改为顺序表末尾" << endl;
	}
	else if(pos<0)
	{
		pos = 0;
		cout << "已经将pos位置改成0号位置元素" << endl;
	}
	for (int i =this->m_length ;i>pos-1;i--)
	{
		this->m_data_pointer[i + 1] = this->m_data_pointer[i];
	}
	this->m_data_pointer[pos] = *item;
	cout << "数据插入成功" << endl;
	this->m_length++;
	return 1;
}
#pragma endregion
#pragma region 删除指定位置的元素
template<typename T,int MaxSize>
int SeqList<T, MaxSize>::DeleteElement(int pos, T* item)
{
	bool result = this->GetElement(pos, item);//有元素
	if (result == true)
	{
		for (int i = pos; i < this->m_length; i++)
		{
			*(this->m_data_pointer + i) = *(this->m_data_pointer + i+1);
		}
		this->m_length--;
		return 0;
	}
	return -1;
}
#pragma endregion
#pragma region 顺序表末尾附加元素
template<typename T,int MaxSize>
bool SeqList<T, MaxSize>::AppendElement(const T* item)
{
	T* temp =const_cast<T*>(item);
	int length = this->m_length+1;
	int capacity = this->m_capacity;
	if (length >= capacity)
	{
		return false;
	};
	int pos = this->InsertElement(temp, this->ListLength());
	return true;
}
#pragma endregion

SeqList.h函数

#pragma once
#include <iostream>

using namespace std;
#ifndef _SEQLIST_H_
#define _SEQLIST_H_
template <typename T, int MaxSize/*顺序表SeqList的尺寸*/>
class SeqList
{
public:
	SeqList(int i);
	~SeqList();
	/*清除链表的数据*/
	void ClearList();
	/*判断链表是否为空*/
	bool IsEmpty();/*1表示空，0表示非空*/
	/*获取SeqList长度*/
	int ListLength();
	/*查找指定下标的元素*/
	bool GetElement(int pos, T *item);
	/*按值查找，求顺序表中值为item的元素序号*/
	int LoateElement(const T* item);
	/*查找元素的前驱元素*/
	bool PriorElement(const T* current, T* prior);
	/*查找current元素的后继元素*/
	bool NextElement(const T* current, T* next);
	/*遍历线性表输出元素*/
	void TraverseList();
	/*在指定位置插入元素*/
	int InsertElement(/*this**/T* item, int pos);
	/*删除指定位置的元素*/
	int DeleteElement(int pos, T* item);
	/*顺序表末尾附加元素*/
	bool AppendElement(const T* item);
private:
	/*类成员*/
	int m_capacity;
	int m_length;
	T* m_data_pointer;
};
#endif // !_SEQLIST_H_