【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;
	}
}