数据结构与算法c++实现（6）之动态数组实现栈

对于栈的概念什么的，我就不在这里念叨啦，网上真正用C++来实现的还不多，这里我将我的源码贴出来，觉得自己写的还算可以，供大家参考。

代码：

#ifndef _MYTOOLS_H
#define _MYTOOLS_H

#include <iostream>
#include <algorithm>

/**********************************************************
这个函数是用来实现动态数组的，由于数组的大小是不能改变的，
所以当数组存满的时候，必须重新开辟一个内存空间，将原来的
数组内容复制到新开辟的空间中。
***********************************************************/
template<class T>
void Change_Size(T* &array_name, const int& Old_size, const int& New_size)
{
	if(New_size <= 0 ){
		throw "New_size must be more than zero";
	}
	T* temp = new T[New_size];
	int num = std::min(Old_size, New_size);//可以增大尺寸，也可以减小尺寸
	std::copy(array_name, array_name + num, temp);
	delete[] array_name;//将原空间释放掉
	array_name = temp;
}

#endif

#ifndef _ARRAYSTACK_H
#define _ARRAYSTACK_H

#include "Mytools.h"

template<class T>
class ArrayStack{
	public:
		ArrayStack(int StackCapacity = 10);
		~ArrayStack();
		ArrayStack(const ArrayStack<T>& OldStack);//深拷贝构造函数
		const ArrayStack<T>& operator= (const ArrayStack<T>& OldStack);
		bool IsEmpty() const;//判断是否为空
		T& GetTop();//得到栈顶的元素
		void Push(const T& item);//在顶部添加一个元素
		void Pop();//从顶部去掉一个元素
	private:
		T* stack;
		int Top;
		int capacity;
		
};

template<class T>
ArrayStack<T>::ArrayStack(int StackCapacity ) : capacity(StackCapacity), Top(-1){
	stack = new T[capacity];
}

template<class T>
ArrayStack<T>::~ArrayStack(){
	delete[] stack;  
} 

template<class T>
ArrayStack<T>::ArrayStack(const ArrayStack<T>& OldStack) {
	this->Top = OldStack.Top;
	this->capacity = OldStack.capacity;
	this->stack = new T[OldStack.capacity];
	std::copy(OldStack.stack, OldStack.stack + OldStack.capacity, this->stack);
}
template<class T>
const ArrayStack<T>& ArrayStack<T>::operator= (const ArrayStack<T>& OldStack) {
	this->Top = OldStack.Top;
	this->capacity = OldStack.capacity;
	delete[] this->stack;
	this->stack = new T[OldStack.capacity];
	std::copy(OldStack.stack, OldStack.stack + OldStack.capacity, this->stack);

	return OldStack;

}

template<class T>
inline bool ArrayStack<T>::IsEmpty() const{
	return Top == -1;
}

template<class T>
T& ArrayStack<T>::GetTop(){
	return stack[Top];
}

template<class T>
void ArrayStack<T>::Push(const T& item){
	if(Top == capacity - 1){
		Change_Size(stack, capacity, capacity*2);
		capacity = capacity*2;
	}
	stack[++Top] = item;
}

template<class T>
void ArrayStack<T>::Pop(){
	if(IsEmpty()){
		throw "stack is empty!!!";
	}
	stack[Top--].~T();//我们的栈可以是可以存储类的，这个时候我们就需要主动调用析构函数 
	
}
#endif

#include "ArrayStack.h"
#include <iostream>

using namespace std;

int main() {

	ArrayStack<int> a(20);
	for (int i = 0; i < 30; i++) {
		a.Push(i);
	}

	ArrayStack<int> b(a);
	ArrayStack<int> c = a;
	ArrayStack<string> d;
	d.Push("hello stack");
	cout << a.GetTop() << endl;
	cout << b.GetTop() << endl;
	cout << c.GetTop() << endl;
	cout << d.GetTop() << endl;
	return 0;
}

结果：

29
29
29
hello stack