C++采用模板实现栈的方法
今天又看了遍《effective C++》,手动实现了一下条款42中的栈，贴出来当博客的处女贴。
首先栈的声明如下，采用了模板传入类型，而栈的底层采用是个链表。
// stack.h // by Chwen 2014-10-27 #include<stdio.h> #include <stdlib.h> #include <iostream> using namespace std; // 栈声明 template<typename T> class Stack { public: Stack(); ~Stack(); void push(const T& node); T Top(); void pop(); int size()const; bool Empty() const; void clear(); private: struct StackNode { T data; StackNode* next; StackNode(const T& Newdata, StackNode* nextNode) :data(Newdata),next(nextNode) {} }; StackNode * top; // 防止默认拷贝和默认赋值 Stack(const Stack& rhs); Stack& operator=(const Stack& rhs); int mySize; };
而对应的cpp实现如下：
// stack.cpp #include "stack.h" using namespace std; // 栈实现 template<typename T> Stack<T>::Stack() :top(nullptr),mySize(0) { } template<typename T> Stack<T>::~Stack() { clear(); } template<typename T> void Stack<T>::push(const T& node) { top = new StackNode(node,top); mySize ++; } template<typename T> T Stack<T>::Top() { if (Empty()) { _DEBUG_ERROR("Error, stack is empty!"); } return top->data; } template<typename T> void Stack<T>::pop() { if (Empty()) { _DEBUG_ERROR("Error, stack is empty!"); } StackNode* topOfStack = top; top = top->next; delete topOfStack; topOfStack = nullptr; mySize --; return; } template<typename T> bool Stack<T>::Empty() const { return top == nullptr; } template<typename T> void Stack<T>::clear() { while (top) { StackNode* topOfStack = top; top = top->next; delete topOfStack; } mySize = 0; } template<typename T> int Stack<T>::size()const { return mySize; }
以上即是采用模板实现的栈的所有代码，可以实现栈的push, pop, top, clear 等操作。
以下写了一个简单的测试代码：
void funv() { Stack<int> s; for(int i = 0; i < 10; ++i) { s.push(i); } for(int j = s.size()-1 ; j >= 0; --j) { cout<< "node: " << s.Top() <<endl; s.pop(); } s.clear(); }
int main ()
{
funv();
getchar();
return 0;
}
之后effective C++指出了另一种更精巧的方式实现，即私有继承。
代码实现如下：
// stack.h // by Chwen 2014-10-27 #include<stdio.h> #include <stdlib.h> #include <iostream> class commonStack { protected: commonStack(); ~commonStack(); void push(void* node); void* Top(); void pop(); int size()const; bool Empty() const; void clear(); private: struct StackNode { void* data; StackNode* next; StackNode(void* Newdata, StackNode* nextNode) :data(Newdata),next(nextNode) {} }; StackNode * top; // 防止默认拷贝和默认赋值 commonStack(const commonStack& rhs); commonStack& operator=(const commonStack& rhs); int mySize; }; template <typename T> class Stack:private commonStack { public: void push(T * ty){commonStack::push(static_cast<void*>(ty));} T* top(){return static_cast<T*>(commonStack::Top());} void pop(){return commonStack::pop();} int size(){return commonStack::size();} bool Empty()const{ return commonStack::Empty(); } void clear(){return commonStack::clear();} };
对应的cpp 如下：
#include "stack.h" using namespace std; commonStack::commonStack() :top(nullptr),mySize(0) { } commonStack::~commonStack() { clear(); } void commonStack::push(void* node) { top = new StackNode(node,top); mySize ++; } void* commonStack::Top() { if (Empty()) { _DEBUG_ERROR("Error, stack is empty!"); } return top->data; } void commonStack::pop() { if (Empty()) { _DEBUG_ERROR("Error, stack is empty!"); } StackNode* topOfStack = top; top = top->next; delete topOfStack; topOfStack = nullptr; mySize --; return; } bool commonStack::Empty() const { return top == nullptr; } void commonStack::clear() { while (top) { StackNode* topOfStack = top; top = top->next; delete topOfStack; } mySize = 0; } int commonStack::size()const { return mySize; }
这里commonStack将原模板类的T改为了void*, 之后使用protected保护该类不会被其他不明群众调用，而是给出了一个模板接口类私有继承这个类，这样一来，既起到了保护作用，又在低损耗的情况下给出了方便易用的接口，巧夺天工的设计。
测试代码如下：
void funcInt() { int* a[10]; for(int i = 0 ; i < 10; ++i) { a[i] = new int(i); } Stack<int> s; for(int j = 0 ; j < 10; ++j) { s.push(a[j]); } int k = s.size(); int* t = s.top(); s.pop(); if(s.Empty()) { cout<<"empty"<<endl; } s.clear(); for(int i = 0 ; i < 10; ++i) { delete a[i] ; } } void funcString() { string* str[10]; for(int i = 0 ; i < 10; ++i) { str[i] = new string("a"); } Stack<string> s; for(int j = 0 ; j < 10; ++j) { s.push(str[j]); } int k = s.size(); string* t = s.top(); s.pop(); if(s.Empty()) { cout<<"empty"<<endl; } s.clear(); for(int i = 0 ; i < 10; ++i) { delete str[i] ; } } int main () { funcInt(); funcString(); getchar(); return 0; }
测试代码没有输出，可以断点看数据。
之后我又去看了一眼STL对栈的实现，它默认使用deque作为栈的底层实现。
template<class _Ty,
class _Container = deque<_Ty> >
class stack { // 栈实现 }
调用的时候直接std::stack<int> 即默认使用deque作为栈底层容器。
用户也可以指定其他方式，比如std::stack<int, std::list<int> >, 这样就使用了list作为栈的底层容器。
让我感到awesome的是STL实现的精巧和灵活性，居然是可指定底层的一种实现方法，太精巧了。回头再去看一下《STL源码剖析》。
只罗列了代码，没太详细的介绍原理，感兴趣的可以直接去看《effective C++》和《STL源码剖析》，以及STL的stack代码。
引用请注明出处，http://www.cnblogs.com/chwen/p/4055474.html 非常感谢，随时交流。