纪念逝去的岁月——C++实现一个栈（使用类模板）

这个版本是上个版本的加强版，上个版本的代码：http://www.cnblogs.com/fengbohello/p/4542912.html

1、代码

2、运行结果

1、代码

1.1 调试信息的配置

//一个调试开关，如果要看调试信息，就把这个开关的注释去掉

//#define USEDEBUG

//如果调试开关打开了，就定义好调试的输出函数（其实是个宏），

#ifdef USEDEBUG

#define DEBUG(fmt, arg...)\

    do{\

        printf("%s %d %s() : ", __FILE__, __LINE__, __func__);\

        printf(fmt, ##arg);\

    }while()

#else

//如果没有打开，这个函数什么也不做

#define DEBUG(fmt, arg...)

#endif

1.2 栈类的声明

//定义模版类 ClsStack

template<typename T> class ClsStack

{

    //这个类的=型私有数据，主要用于对栈的内存分配进行管理，

    //用户不需要关心内存，只需要调用对外提供的几个方法就可以了

    private :

        T ** __m_Data;//存储数据的内存开始地址

        int  __m_pos;//记录栈尾的位置，插入数据时插入这个位置

        int  __m_memsize;//记录内存的总数

    protected :

        //重新分配内存空间，可以减小，也可以增大

        int __resize(int n);

        //获取给定参数的双倍内存，其实主要目的是防止参数是0

        int __doublesize(int n);

    public :

        ClsStack(int n = );

        ~ClsStack();

        //弹出栈顶

        int  pop (T ** ppData);

        //获取栈顶元素，但是不弹出

        int  top (T ** ppData);

        //向栈添加数据

        int  push(T * pData);

        //清空整个栈的数据

        int clear(void (*)(T*));

        //输出整个栈的数据，用于调试

        void printStack(T * p[], int pos);

};

1.3 构造函数的实现

//构造函数

//默认参数值是0

//参数非零时的作用是用于初始化栈空间的大小

template<typename T> ClsStack<T>::ClsStack(int n)

{

    __m_Data = NULL;

    __m_pos = -;

    __m_memsize = ;

    if( != n)

    {

        __m_Data = new T * [n];

        if(NULL != __m_Data)

        {

            __m_memsize = n;

        }

    }

}

1.4）析构函数的实现

//析构函数

//在栈对象被销毁时，需要把申请的内存空间释放

template<typename T> ClsStack<T>::~ClsStack()

{

    if(NULL != __m_Data)

    {

        delete __m_Data;

        __m_Data = NULL;

    }

    __m_pos = -;

    __m_memsize = ;

}

1.5）内存控制函数

//计算新的内存空间

//当参数是0的时候，指定内存空间是1

//参数不是0的时候，内存加倍

template<typename T> int ClsStack<T>::__doublesize(int n)

{

    int x = ;

    if( == n)

    {

        x = ;

    }

    else

    {

        x = n * ;

    }

    return x;

}

//重新设定栈的大小

//就是扩展当前的内存容量到指定的大小

template<typename T> int ClsStack<T>::__resize(int n)

{

    T ** p = new T * [n];

    if(NULL == p)

    {

        return -;

    }

    memset(p, , 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 -;

        }

        //printStack(p, __m_pos);

        delete __m_Data;

    }

    __m_Data = p;

    __m_memsize = n;

    return ;

}

1.6）栈操作函数的实现

//弹出数据

//数据通过参数指定的指针返回

template<typename T> int ClsStack<T>::pop(T ** ppData)

{

    if(NULL == ppData)

    {

        return -;

    }

    int r = ;

    if(- == __m_pos)

    {

        *ppData = NULL;

        r = -;

    }

    else

    {

        *ppData = __m_Data[__m_pos --];

        r = ;

        DEBUG("memsize : [%u], pos : [%d], p = [0X%08X]\n", __m_memsize, __m_pos + , (unsigned int)*ppData);

    }

    return r;

}

//获取栈顶元素，并不弹出

template<typename T> int ClsStack<T>::top(T ** ppData)

{

    if(NULL == ppData)

    {

        return -;

    }

    int r = ;

    if(- == __m_pos)

    {

        *ppData = NULL;

        r = -;

    }

    else

    {

        *ppData = __m_Data[__m_pos];

        r = ;

    }

    return r;

}

//向栈压入元素

//栈会自己判断内存，如果内存不足会自动增加内存

template<typename T> int ClsStack<T>::push(T * pData)

{

    if(__m_pos +  >= __m_memsize)

    {

        int n = __doublesize(__m_memsize);

        if( != __resize(n))

        {

            return -;

        }

    }

    __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 ;

}

1.7）清空栈数据函数

//清空栈，需要指定回收元素数据的函数，

//否则无法知道如何回收由用户申请的内存空间

template<typename T> int ClsStack<T>::clear(void (*F)(T *))

{

    if(NULL == F && __m_pos >= )

    {

        return -;

    }

    if(NULL != __m_Data &&  != __m_memsize)

    {

        for(int i = ; i <= __m_pos; i++)

        {

            F(__m_Data[i]);

            __m_Data[i] = NULL;

        }

        delete __m_Data;

    }

    __m_Data = NULL;

    __m_pos = -;

    __m_memsize = ;

}

1.8）调试辅助函数

//输出栈的内存状态，调试时使用

template<typename T> void ClsStack<T>::printStack(T * p[], int pos)

{

    int i = ;

    for(i = ; i <= pos; i++)

    {

        printf("[%08u] = [0X%08X]\n", i, NULL == p ?  : p[i]);

    }

    printf("----------------------------\n");

}

1.9）测试代码

//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()

int main()

{

    ClsStack<int> objStack;

    int x = ;

    int * p = &x;

    //向栈内压入数据

    objStack.push(p);

    int i = ;

    for(i = ; i <= ; i++)

    {

        int * z = new int;

        *z = i;

        objStack.push(z);

    }

    //开始弹出数据

    for(i = ; i >= ; 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);

}

完整代码如下（折叠了）：

 /*

  * =====================================================================================

  *

  *       Filename:  stack.cpp

  *

  *    Description:  a template stack library

  *

  *        Version:  1.0

  *        Created:  10/13/2016 09:52:46 AM

  *       Revision:  none

  *       Compiler:  gcc

  *

  *         Author:  YOUR NAME (fengbohello@foxmail.com),

  *   Organization:

  *

  * =====================================================================================

  */

 #include <stdio.h>

 #include <string.h>

 //一个调试开关，如果要看调试信息，就把这个开关的注释去掉

 //#define USEDEBUG

 //如果调试开关打开了，就定义好调试的输出函数（其实是个宏），

 #ifdef USEDEBUG

 #define DEBUG(fmt, arg...)\

     do{\

         printf("%s %d %s() : ", __FILE__, __LINE__, __func__);\

         printf(fmt, ##arg);\

     }while()

 #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);

         //获取给定参数的双倍内存，其实主要目的是防止参数是0

         int __doublesize(int n);

     public :

         ClsStack(int n = );

         ~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 = -;

     __m_memsize = ;

     if( != 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 = -;

     __m_memsize = ;

 }

 //计算新的内存空间

 //当参数是0的时候，指定内存空间是1

 //参数不是0的时候，内存加倍

 template<typename T> int ClsStack<T>::__doublesize(int n)

 {

     int x = ;

     if( == n)

     {

         x = ;

     }

     else

     {

         x = n * ;

     }

     return x;

 }

 //重新设定栈的大小

 //就是扩展当前的内存容量到指定的大小

 template<typename T> int ClsStack<T>::__resize(int n)

 {

     T ** p = new T * [n];

     if(NULL == p)

     {

         return -;

     }

     memset(p, , 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 -;

         }

         //printStack(p, __m_pos);

         delete __m_Data;

     }

     __m_Data = p;

     __m_memsize = n;

     return ;

 }

 //弹出数据

 //数据通过参数指定的指针返回

 template<typename T> int ClsStack<T>::pop(T ** ppData)

 {

     if(NULL == ppData)

     {

         return -;

     }

     int r = ;

     if(- == __m_pos)

     {

         *ppData = NULL;

         r = -;

     }

     else

     {

         *ppData = __m_Data[__m_pos --];

         r = ;

         DEBUG("memsize : [%u], pos : [%d], p = [0X%08X]\n", __m_memsize, __m_pos + , (unsigned int)*ppData);

     }

     return r;

 }

 //获取栈顶元素，并不弹出

 template<typename T> int ClsStack<T>::top(T ** ppData)

 {

     if(NULL == ppData)

     {

         return -;

     }

     int r = ;

     if(- == __m_pos)

     {

         *ppData = NULL;

         r = -;

     }

     else

     {

         *ppData = __m_Data[__m_pos];

         r = ;

     }

     return r;

 }

 //向栈压入元素

 //栈会自己判断内存，如果内存不足会自动增加内存

 template<typename T> int ClsStack<T>::push(T * pData)

 {

     if(__m_pos +  >= __m_memsize)

     {

         int n = __doublesize(__m_memsize);

         if( != __resize(n))

         {

             return -;

         }

     }

     __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 ;

 }

 //清空栈，需要指定回收元素数据的函数，

 //否则无法知道如何回收由用户申请的内存空间

 template<typename T> int ClsStack<T>::clear(void (*F)(T *))

 {

     if(NULL == F && __m_pos >= )

     {

         return -;

     }

     if(NULL != __m_Data &&  != __m_memsize)

     {

         for(int i = ; i <= __m_pos; i++)

         {

             F(__m_Data[i]);

             __m_Data[i] = NULL;

         }

         delete __m_Data;

     }

     __m_Data = NULL;

     __m_pos = -;

     __m_memsize = ;

 }

 //输出栈的内存状态，调试时使用

 template<typename T> void ClsStack<T>::printStack(T * p[], int pos)

 {

     int i = ;

     for(i = ; i <= pos; i++)

     {

         printf("[%08u] = [0X%08X]\n", i, NULL == p ?  : 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()

 int main()

 {

     ClsStack<int> objStack;

     int x = ;

     int * p = &x;

     //向栈内压入数据

     objStack.push(p);

     int i = ;

     for(i = ; i <= ; i++)

     {

         int * z = new int;

         *z = i;

         objStack.push(z);

     }

     //开始弹出数据

     for(i = ; i >= ; 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);

 }

2、运行结果

　　2.1、编译

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

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

　　2.2、运行结果

$ ./stack

[SUCCESS   ]

[SUCCESS   ]

[SUCCESS   ]

[SUCCESS   ]

[SUCCESS   ]

[SUCCESS   ]

[SUCCESS   ]

[SUCCESS   ]

[SUCCESS   ]

[SUCCESS   ]

[SUCCESS   ]

[SUCCESS   ]

本文同步发表于博客园：http://www.cnblogs.com/fengbohello/p/4547598.html

作者：风波

mail: fengbohello@foxmail.com

纪念逝去的岁月——C++实现一个栈（使用类模板）的更多相关文章

纪念逝去的岁月——C++实现一个栈
1.代码 2.运行结果 1.代码 stack.cpp #include <stdio.h> #include <string.h> class ClsStack { priva ...
纪念逝去的岁月——C++实现一个队列（使用类模板）
1.代码 2.运行结果 1.代码 #include <stdio.h> #include <string.h> template <typename T> clas ...
纪念逝去的岁月——C/C++排序二叉树
1.代码 2.运行结果 3.分析 1.代码 #include <stdio.h> #include <stdlib.h> typedef struct _Node { int ...
纪念逝去的岁月——C/C++二分查找
代码 #include <stdio.h> int binarySearch(int iList[], int iNum, int iX, int * pPos) { if(NULL == ...
纪念逝去的岁月——C/C++快速排序
快速排序代码 #include <stdio.h> void printList(int iList[], int iLen) { ; ; i < iLen; i++) { pri ...
纪念逝去的岁月——C/C++交换排序
交换排序代码 #include <stdio.h> void printList(int iList[], int iLen) { ; ; i < iLen; i++) { pri ...
纪念逝去的岁月——C/C++选择排序
选择排序代码 #include <stdio.h> void printList(int iList[], int iLen) { ; ; i < iLen; i++) { pri ...
纪念逝去的岁月——C/C++冒泡排序
冒泡排序代码 #include <stdio.h> void printList(int iList[], int iLen) { ; ; i < iLen; i++) { pri ...
纪念逝去的岁月——C/C++字符串回文
判断字符串是否是回文: 1. 输入:hello world dlrow olleh 输出:1 2. 输入:nihao hello 输出:0 代码 #include <stdio.h> #i ...

随机推荐

golang json 包简单分析
首先上代码: func main() { b := true a1, _ := json.Marshal(b) a2, _ := Marshal(b) fmt.Println(string(a1)) ...
Oracle性能优化之SQL语句
1.SQL语句执行过程 1.1 SQL语句的执行步骤 1)语法分析,分析语句的语法是否符合规范,衡量语句中各表达式的意义. 2)语义分析,检查语句中涉及的所有数据库对象是否存在,且用户有相应的权限. ...
hdu 3709 数位dp
数位dp,有了进一步的了解,模板也可以优化一下了题意:找出区间内平衡数的个数,所谓的平衡数,就是以这个数字的某一位为支点,另外两边的数字大小乘以力矩之和相等,即为平衡数例如4139,以3为支点4*2 ...
Java eclipse下 Ant build.xml实例详解
在有eclipse集成环境下ant其实不是很重要,但有些项目需要用到,另外通过eclipse来学习和理解ant是个很好的途径,所以写他demo总结下要点,希望能够帮到大家. 一.本人测试环境eclip ...
RobotFramework自动化测试之环境搭建安装教程（一）
RobotFramework是基于Python语言的工具,所以装RF之前要先安装Python: Python现在有2.7跟3.5两个版本,如果是先装了3.5的话,是装不了2.7的.只有先装2.7的才 ...
CSS总结1
新增:修改placeholder样式 ::-moz-placeholder{color:red;} //ff19+ :-moz-placeholder{color:red} //ff18- ::-we ...
hdu 3518 Boring counting 后缀数组基础题
Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 65536/32768 K (Java/Others)Total Submission( ...
当 NSDictionary 遇见 nil
Demo project: NSDictionary-NilSafe 问题相信用 Objective-C 开发 iOS 应用的人对下面的 crash 不会陌生: *** -[__NSPlacehol ...
不同java 版本的新功能
Java 5 泛型自动装箱/拆箱增强的for 类型安全的枚举可变参数静态导入 Annotation Concurrent Package Java 6 Web Service 支持Annota ...
storm安装笔记以及提交拓扑任务
Storm -- Distributed and fault-tolerant realtime computation 这是一个分布式的.容错的实时计算系统把Storm依赖组件的版本贴出来供各位参 ...

纪念逝去的岁月——C++实现一个栈（使用类模板）

纪念逝去的岁月——C++实现一个栈（使用类模板）的更多相关文章

随机推荐

热门专题