数据结构之线性结构

 数据结构学习虚函数，几个知识点

1：抽象类函数本身不能直接实例化，需要其子类实例化虚函数，才能实例化。继承抽象类的子类必须重写虚函数，具体函数可实现，也可不实现。

2：const修饰符，若修饰函数，则函数参数不能被改变。若修饰成员变量，则成员变量在使用过程中不被改变。修饰传入参数，则避免参数被改变。

3：模板类的实现最好在一个头文件中实现，若是分别实现可能出现异常。

4：函数重载的实现，在头文件中定义，并在cpp文件中进行具体的实现，应用操作符operator实现。

template <class T>
class linearList
{
public:
	virtual ~linearList() {};

	/*brief 返回true，当且今当链表为空 */
	virtual bool    
		empty() const = 0;  

	/*brief 返回线性表的大小 */
	virtual int      
		size() const = 0;

	/*brief 返回线性表中索引号为theIndex的元素*/
	virtual T& 
		get(int theIndex) const = 0;

	/*brief 返回线性表中第一次出现的x索引。若x不存在，则返回-1 */
	virtual int
		indexOf(const T& element) const = 0;

	/*brief 删除索引为index的元素，索引大于index的元素索引减1 */
	virtual void
		erase(int theIndex)  = 0; //这个 = 0 前加上const就表示常量函数
								  //表示函数不能被修改，和继承类要一致

	/*brief 把x插入线性表中索引为index的位置上，索引位置大于index的元素索引加1 */
	virtual void
		insert(int theIndex, const T& theElement)  = 0;

	/*brief 从左至右输出表元素 */
	virtual void output(std::ostream& out) const = 0;
};

 

#pragma once
#include "illegalParameterValue.h" //自定义异常类
#include "linearList.h"

template <class T>
class arrayList : public linearList<T>
{
public:
	//构造函数，复制构造函数和析构函数
	arrayList(int initialCapacity = 10);
	arrayList(const arrayList<T>&);
	~arrayList() { delete[] element; }
	///方法
	bool empty() const { return listSize == 0; }
	int size() const { return listSize; }
	T& get(int theIndex)const;
	int indexOf(const T& theElement) const;
	void erase(int theIndex);
	void insert(int theIndex, const T& theElement);
	void output(std::ostream & out) const;

    T& operator[](int);
	int capcity() const { return arrayLength; }
protected:
	/*brief 若索引无效，则抛出异常 */
	void checkIndex(int theIndex) const;

	T* element;
	int arrayLength;  // 数组所占用的总空间
	int listSize;     // 数组个数
};

template<class T>
inline arrayList<T>::arrayList(int initialCapacity)
{
	if (initialCapacity < 1)
	{ 
		std::ostringstream s;
		s << "Initial capacity = " << initialCapacity << "Must be > 0";*/
		throw illegalParameterValue(s.str());
	}

	arrayLength = initialCapacity;
	element = new T[arrayLength];
	listSize = 0;
}

template<class T>
arrayList<T>::arrayList(const arrayList<T>& theList)
{//复制构造函数，深度复制，避免两个指针指向同一个内存块
 //当释放对象时两次释放内存，导致一个指针悬挂而出现异常
	arrayLength = theList.arrayLength;
	listSize = theList.listSize;
	element = new T[arrayLength];
	copy(theList.element, theList.element + listSize, element);
}

template<class T>
T & arrayList<T>::get(int theIndex) const
{
	// TODO: 在此处插入 return 语句
	return T;
}

template<class T>
int arrayList<T>::indexOf(const T & theElement) const
{
	return 0;
}

template<class T>
void arrayList<T>::erase(int theIndex)
{
}

template<class T>
void arrayList<T>::insert(int theIndex, const T & theElement)
{
}

template<class T>
void arrayList<T>::output(std::ostream & out) const
{
}

template<class T>
void arrayList<T>::checkIndex(int theIndex) const
{
}

template<class T>
T&  arrayList<T>::operator[](int theIndex) 
{//索引theIndex下的元素引用
     return element[theIndex];   
}

在arrayList类中的几个方法都没有进行具体的实现，但重载虚函数。

参考：

      《数据结构、算法与应用》c++语言描述        作者：萨特吉.萨尼      译：王立柱  刘志红