标准模板库(STL)学习探究之Stack容器
C++ Stacks(堆栈)
Stack是一个容器类的改编——也就是说实现了一个先进后出（FILO）的数据结构。stack不直接维护被控序列的模版类，而是它存储的容器对象来为它实现堆栈的所有功能。值得注意的是迭代器不能在堆栈中使用,因为只有栈顶的元素才可以访问。
typedef stack<T,deque<T,allocator<T>>>mystack
默认的参数中容器是用deque实现的；被包含的容器要满足提供value_type，size_type，empt，size，push_back，pop_back；可选择的容器有list，deque，vector；要求有最快的平均访问速度，而且大概的容量要求也清楚(比较衡定)，那么，使用vector是个不错的选择 要求每次的访问时间平稳，而不在乎平均访问时间时，那么，可以考虑使用list；所以，库默认的deque是个不错的选择，它介于vector和list之间，并且很好的综合了两者的优势。
函数列表：
运算符操作 比较和分配堆栈
empty() 堆栈为空则返回真
pop() 移除栈顶元素
push() 在栈顶增加元素
size() 返回栈中元素数目
top() 返回栈顶元素
////////////////////////////////////////////////////////////////////////////////////
构造函数
explicit stack(const allocator_type& al = allocator_type());
1.stack() 声明一个空栈；
2.stack(copy)用一个栈对象copy初始化新栈。
运算符操作
语法:
==
<=
>=
<
>
!=
所有的这些操作可以被用于堆栈. 相等指堆栈有相同的元素并有着相同的顺序。
empty
语法: bool empty();
如当前堆栈为空，empty() 函数 返回 true 否则返回false.
pop
语法: void pop();
pop() 函数移除堆栈中最顶层元素。
push
void push( const TYPE &val );
push() 函数将 val 值压栈，使其成为栈顶的第一个元素。如:
stack<int> s;
for( int i=0; i < 10; i++ )
s.push(i);
size
语法: size_type size();
size() 函数返当前堆栈中的元素数目。如:
stack<int> s;
for( int i=0; i < 10; i++ )
s.push(i);
cout << "This stack has a size of " << s.size() << endl;
top
语法: TYPE &top();
top() 函数返回对栈顶元素的引用. 举例,如下代码显现和清空一个堆栈。
while( !s.empty() ) {
cout << s.top() << " ";
s.pop();
}
示例1：
#include <iostream>
#include <vector>
#include <stack>
#include<string>
using namespace std;
void main()
{
typedef stack<string, vector<string, allocator<string> > > _STACK;
_STACK mystack;
mystack.push("hard/n");
mystack.push("work ");
_STACK copystack(mystack);
while(!mystack.empty())
{
cout<<mystack.top();
mystack.pop();
cout<<copystack.top();
copystack.pop();
}
}
示例2：
#include <iostream>
#include <assert.h>
#include <vector>
#include <deque>
#include <list>
#include <stack>
#include <string>
using namespace std;
struct employee
{
public:
employee(long eID, string e_Name, float e_Salary);
public:
long ID; //Employee ID
string name; //Employee Name
float salary; //Employee Salary
};
//员工类构造函数
employee::employee(long eID, string e_Name, float e_Salary)
: ID(eID), name(e_Name), salary(e_Salary) {}
//定义一个用Vector维护被控序列的栈类型
typedef stack<employee, vector<employee, allocator<employee> > > V_EMPLOYEE_STACK;
//定义一个用Deque维护被控序列的栈类型
typedef stack<employee, deque<employee, allocator<employee> > > D_EMPLOYEE_STACK;
//定义一个用List维护被控序列的栈类型
typedef stack<employee, list<employee, allocator<employee> > > L_EMPLOYEE_STACK;
void main(int argc, char* argv[])
{
V_EMPLOYEE_STACK v_employee;
D_EMPLOYEE_STACK d_employee;
L_EMPLOYEE_STACK l_employee;
//下面的三条语句分别构造三个employee对象，然后入容器对象为Vector的栈
v_employee.push(V_EMPLOYEE_STACK::value_type(100, "huahua", 200000));
v_employee.push(V_EMPLOYEE_STACK::value_type(101, "jiafeng", 8000));
v_employee.push(V_EMPLOYEE_STACK::value_type(101, "unknown", 20000));
assert(!v_employee.empty());
//下面这条语句弹出最后入栈的employee对象
v_employee.pop();
//下面的三条语句分别构造三个employee对象，然后入容器对象为Deque的栈
d_employee.push(D_EMPLOYEE_STACK::value_type(100, "huahua", 200000));
d_employee.push(D_EMPLOYEE_STACK::value_type(101, "jiafeng", 8000));
d_employee.push(D_EMPLOYEE_STACK::value_type(101, "unknown", 20000));
assert(!d_employee.empty());
//下面这条语句弹出最后入栈的employee对象
d_employee.pop();
//下面的三条语句分别构造三个employee对象，然后入容器对象为List的栈
l_employee.push(L_EMPLOYEE_STACK::value_type(100, "huahua", 200000));
l_employee.push(L_EMPLOYEE_STACK::value_type(101, "jiafeng", 8000));
l_employee.push(L_EMPLOYEE_STACK::value_type(101, "unknown", 20000));
assert(!l_employee.empty());
//下面这条语句弹出最后入栈的employee对象
l_employee.pop();
cout << "容器对象为Vector的栈是否为空？ " << (v_employee.empty() ? "TRUE" : "FALSE") << endl;
cout << "容器对象为Vector的栈共有" << v_employee.size() << "个employee对象!" << endl;
cout << "容器对象为Deque的栈是否为空？" << (d_employee.empty() ? "TRUE" : "FALSE") << endl;
cout << "容器对象为Deque的栈共有" << d_employee.size() << "个employee对象!" << endl;
cout << "容器对象为List的栈是否为空？" << (l_employee.empty() ? "TRUE" : "FALSE") << endl;
cout << "容器对象为List的栈共有" << l_employee.size() << "个employee对象!" << endl;
}