棧的實現

1）。#ifndef STACK_H
#define STACK_H

#include <exception>

//當對空棧進行一些不合法的操作的時候會拋出這個異常
class CallEmptyStack: public std::exception
{
 public:
  virtual const char* what() const
  {
   return "你要訪問的是個空棧";
  }
};

//對於棧的設計首先動態分配的資源的第一個位置我沒有存儲數據，主要是用來判斷棧
//是否爲空。所以在進行重分配的時候就要注意。當棧進行重新分配的時候將最大值×2
template <typename T>
class Stack
{
 public:
  Stack(int maxSize = 10);
  ~Stack();
  Stack(const Stack &s);
  const Stack<T>& operator = (const Stack &s);
  bool empty() const;
  int lengh() const;
  void push(const T &value);
  void pop();
  T& top();
 private:
  T *m_base;
  T *m_top;     //對於棧中所有的操作都要確保它指向的都是棧頂的數據位置
  int m_size;
  int m_maxSize;
  void newallot();
  void copy(const Stack &s);
};

template <typename T>
void Stack<T>::newallot()
{
 m_maxSize *= 2;
 T *fp = m_base;
 T *sp = m_base;
 m_base = new T[m_maxSize];
 m_top = m_base;

 for (int i = 0; i != m_size; ++i)
 {
  ++m_top;
  ++sp;
  *m_top = *sp;
 }
 delete [] fp;

}

template <typename T>
void Stack<T>::copy(const Stack &s)
{
 T *p = s.m_base;

 for (int i = 0; i != m_size; ++i)
 {
  ++m_top;
  ++p;
  *m_top = *p;
 }
}

template <typename T>
Stack<T>::Stack(int maxSize):m_maxSize(maxSize)
{
 m_base = new T[m_maxSize];
 m_top = m_base;
 m_size = 0;
}

template <typename T>
Stack<T>::~Stack()
{
 delete [] m_base;
}

template <typename T>
Stack<T>::Stack(const Stack &s)
{
 m_maxSize = s.m_maxSize;
 m_size = s.m_size;
 m_base = new T[m_maxSize];
 m_top = m_base;
 copy(s);
}

template <typename T>
const Stack<T>& Stack<T>::operator = (const Stack &s)
{
 if (this != &s)
 {
  delete [] m_base;
  m_maxSize = s.m_maxSize;
  m_size = s.m_size;
  m_base = new T[m_maxSize];
  m_top = m_base;
  copy(s);
 }
 return *this;
}

template <typename T>
inline bool Stack<T>::empty() const
{
 return m_base == m_top;
}

template <typename T>
inline int Stack<T>::lengh() const
{
 return m_size;
}

template <typename T>
void Stack<T>::push(const T &value)
{
 if (m_size + 2 <= m_maxSize)    //這裏之所以要加2是因爲我在分配的時候第一個位置
         //並沒有存數據所以實際分配的是m_maxSize-1個單元
 {
  ++m_top;
  *m_top = value;
  ++m_size;
 }
 else
 {
  newallot();
  ++m_top;
  *m_top = value;
  ++m_size;
 }
}

template <typename T>
inline void Stack<T>::pop()
{
 if (!empty())
 {
  --m_size;
  --m_top;
 }
 else
  throw CallEmptyStack();
}

template <typename T>
inline T& Stack<T>::top()
{
 if (!empty())
  return *m_top;
 else
  throw CallEmptyStack();
}
#endif 

 

2）。#ifndef STACK_H
#define STACK_H

#include <vector>
#include <exception>
using namespace std;

//用vector實現的一個棧，使用已經有的STL實現的時候就是要看看這些操作是否會引發異常
class CallEmptyStack :public exception
{
 public:
  virtual const char* what() const
  {
   return "你訪問的是一個空棧!";
  }
};

template <typename T>
class Stack
{
 public:
  Stack(){};
  ~Stack(){};
  vector<T>::size_type lengh() const;
  bool empty() const;
  T&  top();
  void pop();
  void push(const T &value);
 
 private:
  vector<T> m_vec;

};

template <typename T>
inline vector<T>::size_type Stack<T>::lengh() const
{
 return m_vec.size();
}

template <typename T>
inline bool Stack<T>::empty() const
{
 return m_vec.empty();
}

template <typename T>
T& Stack<T>::top()
{
 if (!m_vec.empty())
  return m_vec.back();
 else
  throw CallEmptyStack();
}

template <typename T>
void Stack<T>::pop()
{
 if (!m_vec.empty())
 {
  vector<T>::iterator ite = m_vec.end() - 1;
  m_vec.erase(ite);
 }
 else
  throw CallEmptyStack();
}
template <typename T>
void Stack<T>::push(const T &value)
{
 m_vec.push_back(value);
}
#endif