类模板、Stack的类模板实现（自定义链栈方式，自定义数组方式）
一、类模板
类模板：将类定义中的数据类型参数化
类模板实际上是函数模板的推广，可以用相同的类模板来组建任意类型的对象集合
（一）、类模板的定义
template <类型形参表>
class <类名>
{ //类说明体 }；
template <类型形参表>
<返回类型> <类名> <类型名表>::<成员函数1>（形参表）
{ //成员函数定义体 }
template <类型形参表>
<返回类型> <类名> <类型名表>::<成员函数2>（形参表）
{ //成员函数定义体 }
…
template <类型形参表>
<返回类型> <类名> <类型名表>::<成员函数n>（形参表）
{ //成员函数定义体 }
（二）、使用类模板
类模板的实例化：用具体的数据类型替换模板的参数以得到具体的类（模板类）
模板类也可以实例化为对象
用下列方式创建类模板的实例：
类名 <类型实参表> 对象名称;
对于函数模板与类模板，模板参数并不局限于类型（类类型，基本类型，模板类实例），普通值也可以作为模板参数
二、Stack类的模板实现
在前面曾经分别使用C/C++实现了一个链栈，栈中只能放进int类型数据，现在使用模板来重新实现Stack，可以存放多种数据类型，分别使用自定义链栈方式以及自定义数组实现。
（一）、自定义链栈方式：
stack.h：
C++ Code
|
1
2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 |
/*************************************************************************
> File Name: stack.h > Author: Simba > Mail: dameng34@163.com > Created Time: 2012年11月03日 星期六 19时28分25秒 ************************************************************************/ #include<iostream> using namespace std; template < class T > class Node { //< >里面是模板参数，可以有多个，虽然T用class 声明，但可以是内建类型也可以是class类型 //模板的定义一般写在头文件里 public: Node(T invalue): m_Value(invalue), m_Next(NULL) {} ~Node(); T getValue() const { return m_Value; } void setValue(T value) { m_Value = value; } Node < T > *getNext() const { return m_Next; } void setNext(Node < T > *next) { m_Next = next; } private: T m_Value; Node < T > *m_Next; }; template < class T > Node < T >::~Node() { if (m_Next) { delete m_Next; //自动内存管理，接着找到m_Next指向的下一个结点，一直找到最后的一个结点 //故先释放最后一个结点（当然是最先压栈的结点），然后依次返回释放每一个途中的结点 } " deleted " << endl;
} template < class T > class Stack { public: Stack(): m_Head(NULL), m_Count(0) {} ~Stack() { delete m_Head; //自动内存管理 } void push(const T &t); T pop(); T top() const; int count() const; private: Node < T > *m_Head; int m_Count; }; template < class T > void Stack < T >::push(const T &value) { Node < T > *newNode = new Node < T > (value); newNode->setNext(m_Head); m_Head = newNode; ++m_Count; } template < class T > T Stack < T >::pop() { Node < T > *popped = m_Head; if (m_Head != NULL) { m_Head = m_Head->getNext(); T retval = popped->getValue(); popped->setNext(NULL); delete popped; --m_Count; return retval; } return 0; } template < class T > inline T Stack < T >::top() const //模板前缀template < class T > || 函数限定符inline 函数返回值T || //命名空间前缀 Stack < T > //一个类型 || 函数名（函数参数）const 限定符 { return m_Head->getValue(); } template < class T > inline int Stack < T >::count() const { return m_Count; } |
main.cpp：
C++ Code
|
1
2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 |
#include "stack.h"
int main(void) { Stack < int >intstack1, intstack2; int val; for (val = 0; val < 4; ++val) { intstack1.push(val); intstack2.push(2 * val); } while (intstack1.count()) { val = intstack1.pop(); cout << val << endl; } Stack < char >stringstack; stringstack.push('A'); stringstack.push('B'); stringstack.push('C'); char val2; while (stringstack.count()) { val2 = stringstack.pop(); cout << val2 << endl; } cout << "Now intstack2 will be destructed." << endl; return 0; } |
可以看到虽然intstack2 没有pop 出元素，但程序结束时，局部对象会被析构，调用析构函数，在析构函数内delete 头指针，顺藤摸瓜一直找到最后一个节点，即首先压栈的节点，依次返回释放掉。
（二）、自定义数组方式
Stack2.h：
C++ Code
|
1
2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 |
#ifndef _STACK2_H_
#define _STACK2_H_ #include <exception> template <typename T, int MAX_SIZE> class Stack2 { public: Stack2(); ~Stack2(); void Push(const T &elem); void Pop(); T &Top(); const T &Top() const; bool Empty() const; private: T *elems_; int top_; }; template <typename T, int MAX_SIZE> Stack2<T, MAX_SIZE>::Stack2() : top_(-1) { elems_ = new T[MAX_SIZE]; } template <typename T, int MAX_SIZE> Stack2<T, MAX_SIZE>::~Stack2() { delete[] elems_; } template <typename T, int MAX_SIZE> void Stack2<T, MAX_SIZE>::Push(const T &elem) { if (top_ + 1 >= MAX_SIZE) throw out_of_range("Stack2<>::Push() Stack2 full"); elems_[++top_] = elem; } template <typename T, int MAX_SIZE> void Stack2<T, MAX_SIZE>::Pop() { if (top_ + 1 == 0) throw out_of_range("Stack2<>::Push() Stack2 empty"); --top_; } template <typename T, int MAX_SIZE> T &Stack2<T, MAX_SIZE>::Top() { if (top_ + 1 == 0) throw out_of_range("Stack2<>::Push() Stack2 empty"); return elems_[top_]; } template <typename T, int MAX_SIZE> const T &Stack2<T, MAX_SIZE>::Top() const { if (top_ + 1 == 0) throw out_of_range("Stack2<>::Push() Stack2 empty"); return elems_[top_]; } template <typename T, int MAX_SIZE> bool Stack2<T, MAX_SIZE>::Empty() const { return top_ + 1 == 0; } #endif // _STACK2_H_ |
main.cpp：
C++ Code
|
1
2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
#include "Stack2.h"
#include <iostream> #include<string> using namespace std; int main(void) { Stack2<int, 5> s; s.Push(1); s.Push(2); s.Push(3); while (!s.Empty()) { cout << s.Top() << endl; s.Pop(); } return 0; } |
输出为 3 2 1
注意，用数组实现时pop 操作并没有删除元素的操作，只是移动了top 指针，下次push 的时候直接覆盖即可。再者因为实现了Top 返回栈顶元素，故pop 没有返回值。
参考：
C++ primer 第四版
Effective C++ 3rd
C++编程规范
