【C++ STL】細數C++ STL 的那些事 -- stack（棧）

 1）Stack是一種關聯容器，是通過簡單地修飾線性類deque的接口而獲得的另一種“容器類”，往往被歸結爲配接器（adapter）而不是容器（container）。

                 stack不能遍歷，所以沒有迭代器！！！

                 底層容器除了 deque外還可採用 list。

                   

            2）使用

                    需加載的頭文件:   #include<stack>
                                                using namespace std;

                   template <class T, class Container = deque<T> >

            3）主要的方法有如下：     

                          empty() 堆棧爲空則返回真

　　                  pop() 移除棧頂元素（不會返回棧頂元素的值） 

　　                  push() 在棧頂增加元素

　　                  size() 返回棧中元素數目

　　                  top() 返回棧頂元素

              4）例子：

#include <iostream>
#include <stack>
using namespace std;
int main()
{
    stack <int> myStack;//定義棧
    myStack.push(5);//壓棧
    myStack.push(6);
    myStack.push(7);
    myStack.pop(); //出棧
    cout<<myStack.top()<<endl;
    cout<<myStack.size()<<endl;
    cout<<myStack.empty()<<endl;
    return 0;
}

讀文件例子

#include <iostream>
#include <fstream>
#include <string>
#include <cstdlib>
#include <stack>
using namespace std;
int main(){
    ifstream inf;
    inf.open("temp.txt");
    if (!inf) {
        cerr<<"cannot open file for input!"<<endl;
        return EXIT_FAILURE;    }
    stack <string> s;
    string line;
    while (getline(inf,line)){//讀入一行文本
        s.push(line); //壓入棧 }
    inf.close();
    while (!s.empty()){//棧不空，輸出棧頂元素
        cout<<s.top()<<endl;
        s.pop();    //彈棧}
    return 0;
}

             5）stack的實現

#include <deque>
#include <stdexcept>
#include <iostream>
using namespace std;

template <typename T>
class stack
{
private:
    deque<T> elems; //實際容器

public:
    void push(T const&);
    void pop(void);
    T top() const;
    bool empty() const
    {
        return elems.empty();
    }

    template<typename T2> //類成員模板
    stack <T>& operator= (stack<T2> const&);

    //實現迭代器。
    typedef const T* const_iterator;
    T* end(void);
    T* begin(void);
};

template <typename T>
template <typename T2>
stack<T>& stack<T>::operator =(const stack<T2> &op2)
{
    if((void*)this == (void*)&op2)
        return *this;
    stack<T2> tmp(op2);
    elems.clear();

    while(!tmp.empty())
    {
        elems.push_front(tmp.top());
        tmp.pop();
    }
    return *this;
}

template <typename T>
void stack<T>::push(T const& elem)
{
    elems.push_back(elem);
}

template <typename T>
void stack<T>::pop()
{
    if(elems.empty())
    throw out_of_range("stack<>::pop() :empty stack");
        elems.pop_back();
}
//實現迭代器。
template <typename T>
T stack<T>::top() const
{
    if(elems.empty())
        throw out_of_range("stack<>::top() :empty stack");
    return elems.back();
}
//指向第一個元素。
template <typename T>
T* stack<T>::begin()
{
    return (&(elems.front()));
}
//這裏要實現的是指向未端的下一元素。
template <typename T>
T* stack<T>::end()
{
    return ((&(elems.back()))+1);
}

int main()
{
    stack<int> intStack;
    stack<int> charStack;

    intStack.push(10);
    intStack.push(19);
    intStack.push(39);

    cout<<"top："<<intStack.top()<<endl;
    cout<<"賦值並輸出："<<endl;

    charStack = intStack;

    stack<int>::const_iterator iterator;
    iterator = charStack.begin();
    while(iterator != charStack.end())
    {
        cout<< *iterator<<endl;
        ++iterator;
    }
}