泛型编程实现堆栈

泛型编程实现堆栈

#ifndef _STACK_H_

#define _STACK_H_
#include <cstdlib>
#include <iostream>
using namespace std;
const int STACK_INIT_SIZE = 1;
const int ADD_SIZE = 10;
template<typename T>
class Stack
{
public:
Stack();
~Stack();
void Destroy();
void Clear();
int Length();
void Top(T &e);
void Pop(T &e);
void Push(const T &e);
bool IsEmpty();
private:
T* base;
T* top;
int size;
};


#endif
template<typename T>
Stack<T>::Stack()
{
base = (T*)malloc(STACK_INIT_SIZE * sizeof(T));
if (!base)
{
cout << "statck init error" << endl;
return;
}
top = base;
size = STACK_INIT_SIZE;
}


template<typename T>
Stack<T>::~Stack()
{
Destroy();
}


template<typename T>
void Stack<T>::Destroy()
{
free(base);
top = nullptr;
base = nullptr;
size = 0;
}


template<typename T>
void Stack<T>::Clear()
{
top = base;
}


template<typename T>
int Stack<T>::Length()
{
return top - base;
}


template<typename T>
void Stack<T>::Top(T &e)
{
if (top > base)
{
e = *(top - 1);
}
else
{
cout << "Top error" << endl;
}
}


template<typename T>
void Stack<T>::Push(const T &e)
{
if (top - base >= size)
{
base = (T*)realloc(base, (size + ADD_SIZE)*sizeof(T));
if (!base)
{
cout << "realloc error" << endl;
}
top = base + size;
size += ADD_SIZE;
}
*(top)++ = e;
}


template<typename T>
bool Stack<T>::IsEmpty()
{
if (base == top)
{
return true;
}
return false;
}


template<typename T>
void Stack<T>::Pop(T &e)
{
if (top > base)
{
e = *(--top);
}
else
{
cout << "Pop error" << endl;
}

}

测试

#include "Stack.h"
#include <iostream>
using namespace std;
int main()
{
Stack<double> stack;
double x;
while (cin >> x)
{
if (x == 999)
{
break;
}
stack.Push(x);
}
cout << "length:" << stack.Length() << endl;
double e;
stack.Top(e);
cout << "top:" << e << endl;
while (!stack.IsEmpty())
{
stack.Pop(e);
cout << e << " ";
}
cout << endl;
stack.Top(e);
cin >> x;
return 0;
}