Stack的c++实现（不完整）

全面解析 Coco AI，一款开源、免费的智能搜索与知识库工具

Stack.h

#ifndef _STACK_H_
#define _STACK_H_
namespace Stack{
	class Stack_error{
		private:
			char* error_msg;
		public:
			Stack_error(char* msg):error_msg(msg){}

			const char* what(){
				return error_msg;
			}
	};

	template<typename T,unsigned MAXLEN>
	class Stack_static_array{
		private:
			T arr[MAXLEN];
			unsigned count;
		public:
			Stack_static_array();
			Stack_static_array(unsigned,T);
			Stack_static_array(const Stack_static_array<T,MAXLEN>&);

			bool empty() const;
			bool full() const;

			void push(const T&) throw(Stack_error);
			void pop() throw(Stack_error);

			T get_top() const throw(Stack_error);
			void print() const;
	};

	template<typename T>
	class Stack_dynamic_array{
		private:
			T *arr;
			unsigned count;
			unsigned size;
			
			void enlarge();
			void lessen();
		public:
			Stack_dynamic_array();
			Stack_dynamic_array(unsigned,T);
			Stack_dynamic_array(const Stack_dynamic_array<T>&);
			~Stack_dynamic_array();

			bool empty() const;

			void push(const T&);
			void pop() throw(Stack_error);

			T get_top() const throw(Stack_error);
			void print() const;

	};	
	
}
#endif
#include"Stack.cpp"

#include<iostream>

template<typename T,unsigned MAXLEN>
Stack::Stack_static_array<T,MAXLEN>::Stack_static_array():count(0){}

template<typename T,unsigned MAXLEN>
Stack::Stack_static_array<T,MAXLEN>::Stack_static_array(unsigned len,T element){
	count=len;
	if(len){
		for(unsigned i=0;i<len;++i){
			arr[i]=element;
		}
	}
}

template<typename T,unsigned MAXLEN>
Stack::Stack_static_array<T,MAXLEN>::Stack_static_array(const Stack_static_array<T,MAXLEN>& oth_obj){		count=oth_obj.count;
	for(unsigned i=0;i<oth_obj.count;++i){
		arr[i]=oth_obj[i];
	}
}

template<typename T,unsigned MAXLEN>
bool Stack::Stack_static_array<T,MAXLEN>::empty() const{
	return count==0;
}

template<typename T,unsigned MAXLEN>
bool Stack::Stack_static_array<T,MAXLEN>::full() const{
	return count==MAXLEN;
}

template<typename T,unsigned MAXLEN>
void Stack::Stack_static_array<T,MAXLEN>::push(const T& element) throw(Stack_error){
	if(count==MAXLEN)
		throw Stack_error("ERROR: FULL Stack!\n");
	else{
		arr[count]=element;
		++count;
	}
}

template<typename T,unsigned MAXLEN>
void Stack::Stack_static_array<T,MAXLEN>::pop() throw(Stack_error){
	if(!count)
		throw Stack_error("ERROR: EMPTY Stack!\n");
	else
		--count;
}

template<typename T,unsigned MAXLEN>
T Stack::Stack_static_array<T,MAXLEN>::get_top() const throw(Stack_error){
	if(!count)
		throw Stack_error("ERROR: EMPTY Stack!\n");
	else
		return arr[count-1];
}

template<typename T,unsigned MAXLEN>
void Stack::Stack_static_array<T,MAXLEN>::print() const{
	using namespace std;
	for(unsigned i=0;i<count;++i)
		cout<<arr[i]<<"  ";
	cout<<endl;
}

template<typename T>
Stack::Stack_dynamic_array<T>::Stack_dynamic_array():count(0),size(1){
	arr=new T[size];
}

template<typename T>
Stack::Stack_dynamic_array<T>::Stack_dynamic_array(unsigned mcount,T element):count(mcount){
	if(mcount){
		if(count<1024){
			size=1;
			while(count>size)
				size*=2;
		}
		else{
			for(size=1024;count>size;size+=1024){}
		}
		arr=new T[size];
		for(unsigned i=0;i<count;++i)
			arr[i]=element;	
	}
	else{
		size=1;
		arr=new T[size];
	}
}

template<typename T>
Stack::Stack_dynamic_array<T>::Stack_dynamic_array(const Stack_dynamic_array<T>& oth_obj){
	count=oth_obj.count;
	size=oth_obj.size;
	arr=new T[size];
	for(unsigned i=0;i<count;++i)
		arr[i]=oth_obj.arr[i];
}

template<typename T>
Stack::Stack_dynamic_array<T>::~Stack_dynamic_array(){
	delete [] arr;
}

template<typename T>
void Stack::Stack_dynamic_array<T>::enlarge(){
	if(size<1024)
		size*=2;
	else
		size+=1024;
	T* temp=new T[size];
	for(unsigned i=0;i<count;++i)
		temp[i]=arr[i];
	delete [] arr;
	arr=temp;
}

template<typename T>
void Stack::Stack_dynamic_array<T>::lessen(){
	if(size!=1){
		if(size>1024)
			size-=1024;
		else
			size/=2;
		T* temp=new T[size];
		for(unsigned i=0;i<count;++i)
			temp[i]=arr[i];
		delete [] arr;
		arr=temp;
	}
}

template<typename T>
bool Stack::Stack_dynamic_array<T>::empty() const{
	return count==0;
}

template<typename T>
void Stack::Stack_dynamic_array<T>::push(const T& element){
	if(count==size)
		enlarge();
	arr[count]=element;
	++count;
}

template<typename T>
void Stack::Stack_dynamic_array<T>::pop() throw(Stack_error){
	if(!count)
		throw Stack_error("ERROR: EMPTY Stack!\n");
	--count;
	if(count==size/2||count==size-1024)
		lessen();
}

template<typename T>
T Stack::Stack_dynamic_array<T>::get_top() const throw(Stack_error){
	if(!count)
		throw Stack_error("ERROR: EMPTY Stack!\n");
	return arr[count-1];
}

template<typename T>
void Stack::Stack_dynamic_array<T>::print() const{
	using namespace std;
	for(unsigned i=0;i<count;++i)
		cout<<arr[i]<<"  ";
	cout<<endl;
}