算法复习--------------基本算法：间接寻址的实现

顺序寻址方式

由于指令地址在内存中按顺序安排，当执行一段程序时，通常是一条指令接一条指令地顺序进行。也就是说，从存储器取出第1条指令，然后执行这条指令；接着从存储器取出第2条指令，再执行第二条指令；接着再取出第3条指令。 [1]  

这种程序顺序执行的过程，称为指令的顺序寻址方式。为此，必须使用程序计数器（又称指令指针寄存器）PC来计数指令的顺序号，该顺序号就是指令在内存中的地址。

跳跃寻址方式

当程序转移执行的顺序时，指令的寻址就采取跳跃寻址方式。所谓跳跃，是指下条指令的地址码不是由程序计数器给出，而是由本条指令给出。注意，程序跳跃后，按新的指令地址开始顺序执行。因此，指令计数器的内容也必须相应改变，以便及时跟踪新的指令地址。

采用指令跳跃寻址方式，可以实现程序转移或构成循环程序，从而能缩短程序长度，或将某些程序作为公共程序引用。指令系统中的各种条件转移或无条件转移指令，就是为了实现指令的跳跃寻址而设置的。 [1]  

#include<ostream>
using namespace std;

template<class T>
class IndirectList{
public:

	IndirectList(int MaxListSize = 10);
	~IndirectList();
	bool IsEmpty()const { return length == 0; }
	int Length()const { return length; }
	bool Find(int k, T& x)const;
	int Search(const T& x)const;
	IndirectList<T>& Delete(int k, T& x);
	IndirectList<T>& Insert(int k, const T& x);
	void Output(ostream& out);
private:
	T **table; //一维T类型指针数组
	int length, MaxSize;
};
//构造函数
template<class T>
IndirectList<T>::IndirectList(int MaxListSize = 10){
	MaxSize = MaxListSize;
	table = new T*[MaxSize];
	length = 0;

}

//析构函数
template<class T>
IndirectList<T>::~IndirectList(){

	for (int i = 0; i < length; i++){
		delete table[i];

	}
	delete[]table;
}


template<class T>
bool IndirectList<T>::Find(int k, T& x) const{
	//取第k个元素至x
	//如果第k个元素不存在，函数返回false，否则返回true

	if(k < 1 || k >length) return false;

	x = *table[k - 1];
	return true;
}

template<class T>
IndirectList<T>& IndirectList<T>::Delete(int k, T& x){
	//把第k个元素传送至x，然后删除第开个元素
	//如果不在村第k个元素，抛出异常
	if (Find(k, x)){
		for (int i = k; i < length; i++){
			table[i - 1] = table[i];

		}
		length--;
		return *this;
	}
	else
	{
		throw;
	}
}


template<class T>
IndirectList<T>& IndirectList<T>::Insert(int k, const T& x){
	//在第k个元素后插入x
	//如果不存在第k个元素，则抛出异常
	//如果没有足够的空间，则抛出异常
	if (k < 0 || k > length) throw;
	if (length == MaxSize) throw;

	for (int i = length - 1; i >= k; i--){
		table[i + 1] = table[i];
	}
	table[k] = new T;
	*table[k] = x;
	length++;

	return *this;

}

template<class T>
void IndirectList<T>::Output(ostream& out){
	for (int i = 0; i < length; i++){
		out << *table[i] << " ";
	}
}


template <class T>
ostream& operator<<(ostream& out, const IndirectList<T>& x){
	x.Output(out);
	return out;
}