//一个调试开关，如果要看调试信息，就把这个开关的注释去掉
//#define USEDEBUG//如果调试开关打开了，就定义好调试的输出函数（其实是个宏），
#ifdef USEDEBUG
#define DEBUG(fmt, arg...)\do{\printf("%s %d %s() : ", __FILE__, __LINE__, __func__);\printf(fmt, ##arg);\}while(0)
#else
//如果没有打开，这个函数什么也不做
#define DEBUG(fmt, arg...)
#endif

//定义模版类 ClsStack
template<typename T> class ClsStack
{//这个类的=型私有数据，主要用于对栈的内存分配进行管理，//用户不需要关心内存，只需要调用对外提供的几个方法就可以了private :T ** __m_Data;//存储数据的内存开始地址int  __m_pos;//记录栈尾的位置，插入数据时插入这个位置int  __m_memsize;//记录内存的总数protected ://重新分配内存空间，可以减小，也可以增大int __resize(int n);//获取给定参数的双倍内存，其实主要目的是防止参数是0int __doublesize(int n);public :ClsStack(int n = 0);~ClsStack();//弹出栈顶int  pop (T ** ppData);//获取栈顶元素，但是不弹出int  top (T ** ppData);//向栈添加数据int  push(T * pData);//清空整个栈的数据int clear(void (*)(T*));//输出整个栈的数据，用于调试void printStack(T * p[], int pos);
};

//构造函数
//默认参数值是0
//参数非零时的作用是用于初始化栈空间的大小
template<typename T> ClsStack<T>::ClsStack(int n)
{__m_Data = NULL;__m_pos = -1;__m_memsize = 0;if(0 != n){__m_Data = new T * [n];if(NULL != __m_Data){__m_memsize = n;}}
}

//析构函数
//在栈对象被销毁时，需要把申请的内存空间释放
template<typename T> ClsStack<T>::~ClsStack()
{if(NULL != __m_Data){delete __m_Data;__m_Data = NULL;}__m_pos = -1;__m_memsize = 0;
}

//计算新的内存空间
//当参数是0的时候，指定内存空间是1
//参数不是0的时候，内存加倍
template<typename T> int ClsStack<T>::__doublesize(int n)
{int x = 0;if(0 == n){x = 1;}else{x = n * 2;}return x;
}//重新设定栈的大小
//就是扩展当前的内存容量到指定的大小
template<typename T> int ClsStack<T>::__resize(int n)
{T ** p = new T * [n];if(NULL == p){return -1;}memset(p, 0, sizeof(T *) * (n));if(NULL != __m_Data){//printStack(__m_Data, __m_pos);if( NULL == memcpy(p, __m_Data, __m_memsize * sizeof(T *))){DEBUG("memcpy faild\n");delete p;return -1;}//printStack(p, __m_pos);delete __m_Data;}__m_Data = p;__m_memsize = n;return 0;
}

//弹出数据
//数据通过参数指定的指针返回
template<typename T> int ClsStack<T>::pop(T ** ppData)
{if(NULL == ppData){return -1;}int r = 0;if(-1 == __m_pos){*ppData = NULL;r = -1;}else{*ppData = __m_Data[__m_pos --];r = 0;DEBUG("memsize : [%u], pos : [%d], p = [0X%08X]\n", __m_memsize, __m_pos + 1, (unsigned int)*ppData);}return r;
}//获取栈顶元素，并不弹出
template<typename T> int ClsStack<T>::top(T ** ppData)
{if(NULL == ppData){return -1;}int r = 0;if(-1 == __m_pos){*ppData = NULL;r = -1;}else{*ppData = __m_Data[__m_pos];r = 0;}return r;
}//向栈压入元素
//栈会自己判断内存，如果内存不足会自动增加内存
template<typename T> int ClsStack<T>::push(T * pData)
{if(__m_pos + 1 >= __m_memsize){int n = __doublesize(__m_memsize);if(0 != __resize(n)){return -1;}}__m_Data[++__m_pos] = pData;DEBUG("memsize : [%u], pos : [%d], p = [0X%08X]\n", __m_memsize, __m_pos, (unsigned int)__m_Data[__m_pos]);return 0;
}

//清空栈，需要指定回收元素数据的函数，
//否则无法知道如何回收由用户申请的内存空间
template<typename T> int ClsStack<T>::clear(void (*F)(T *))
{if(NULL == F && __m_pos >= 0){return -1;}if(NULL != __m_Data && 0 != __m_memsize){for(int i = 0; i <= __m_pos; i++){F(__m_Data[i]);__m_Data[i] = NULL;}delete __m_Data;}__m_Data = NULL;__m_pos = -1;__m_memsize = 0;
}

//输出栈的内存状态，调试时使用
template<typename T> void ClsStack<T>::printStack(T * p[], int pos)
{int i = 0;for(i = 0; i <= pos; i++){printf("[%08u] = [0X%08X]\n", i, NULL == p ? 0 : p[i]);}printf("----------------------------\n");
}

//test 函数定义
#define TEST_EQ(a, b)\do{\if(a == b)\{\printf("\033[0;32m[SUCCESS %5d]\033[0m\n", __LINE__);\}\else\{\printf("\033[0;31m[FAILD   %5d]\033[0m\n", __LINE__);\}\}while(0)int main()
{ClsStack<int> objStack;int x = 10;int * p = &x;//向栈内压入数据
    objStack.push(p);int i = 0;for(i = 0; i <= 10; i++){int * z = new int;*z = i;objStack.push(z);}//开始弹出数据for(i = 10; i >= 0; i--){int * z = NULL;objStack.pop(&z);if(NULL == z){printf("z == NULL\n");continue;}//测试弹出的数据和压入的数据是否一致TEST_EQ(i, *z);delete z;}int * g = NULL;objStack.pop(&g);TEST_EQ(x, *g);
}

g++ -g  -c -o stack.o stack.cpp -Wall -I./
g++ -g  -o stack stack.o -Wall -I./ 

$ ./stack
[SUCCESS   288]
[SUCCESS   288]
[SUCCESS   288]
[SUCCESS   288]
[SUCCESS   288]
[SUCCESS   288]
[SUCCESS   288]
[SUCCESS   288]
[SUCCESS   288]
[SUCCESS   288]
[SUCCESS   288]
[SUCCESS   293]