封装一个栈，队列

一、栈：

特殊的线性表，只能在其一端进行数据插入和删除操作，

特性：先进后出 FIFO

2、模拟实现一个栈

# include<stdio.h>
# include<stdlib.h>
# include<assert.h>
# include<string.h>
# include<iostream>
//引用前面自己实现的顺序表的类的头文件
using namespace std;

//template<class T,class Container=Vector<T>>
//class T:容器类型   class Conainer：底层空间,此时Container若是想要给定
//一个默认的参数，必须实例化的时候需要给定一个具体的类型，不能直接给一个
//Vector，因为Vector是一个模板类，不是具体的类型，此时只能给成Vector<T>
template<class>
class Container
{};//模板类的名字
//template<class T, template<class T> class Container>
template<class T,template<class> class Container=Vector>
//第二个模板参数：模板类。
//template<class> class Container：模板的模板参数：模板类的参数列表<class>，不需要给出模板类的名字，此时
//是一个模板的类型而不是模板类，此时的Vector也是模板类，此时两个模板类（Container和Vector）的参数个数也应该相同
//Container是一个模板类，只接收一个模板类的参数，而且不用把这个参数给出来
//若是此处给定模板的模板类函数<class T>，则后面实例化为对象，也必须给定模板类函数Container<T>
class Stack
{
public:
	//给定构造函数
	Stack()
	{}
	void Push(const T& data)
	{
		_con.PushBack(data);
	}
	void Pop()
	{
		_con.PopBack();
	}
	T& Top()
	{
		return _con.Back();
	}
	const T& Top()const
	{
		return _con.Back();
	}
	size_t Size()const
	{
		return _con.Size();
	}

private:
	Container _con;//创建一个容器的对象//Container是一个具体的类型
	//Container<T> _con;//Container是一个模板类
};
void Test()
{
	Stack<int> s;
	s.Push(1);
	s.Push(2);
	s.Push(3);
	s.Push(4);
	s.Push(5);
	cout << s.Size() << endl;
	cout << s.Top() << endl;
	s.Pop();
	s.Pop();
	cout << s.Size() << endl;
	cout << s.Top() << endl;
}
int main()
{

}

二、模拟实现一个队列

队列是一个特殊的线性结构：只有两种操作：在一端进行数据的插入（队尾），在另一端进行数据的删除操作（队头）

从队头出队列，从队尾入队列

2、封装一个队列

使用模板函数封装一个队列

# include<stdio.h>
# include<stdlib.h>
# include<assert.h>
# include<string.h>
# include<iostream>
using namespace std;
//使用模板参数来实现一个队列
template<class T,class Container=List<T>>
//依靠底层封装的List顺序表，重新封装一个
class Queue
{
public:
	//给出空间
	Queue()
	{}
	void Push(const T& data)
	{
		_con.PushBack(data);
	}
	void Pop()
	{
		_con.PopFront();
	}
	T& Front()
	{
		return _con.Front();
	}
	const T& Front()const
	{
		return _con.Front();
	}
	T& Back()
	{
		return _con.Back();
	}
	const T& Back()const
	{
		return _con.Back();
	}
	size_t Size()const
	{
		return _con.Size();
	}
	bool Empty()const
	{
		return _con.Empty();
	}
private:
        Container _con;
};
void Test()
{
    Queue<int> q;
    q.Push(1);
    q.Push(2);
    q.Push(3);
    q.Push(4);
    q.Push(5);
    cout<<q.Front()<<endl;
    cout<<q.Back()<<endl;
    cout<<q.Size()<<endl;
    q.Pop();
    q.Pop();
    q.Pop();
    cout<<q.Front()<<endl;
    cout<<q.Back()<<endl;
    cout<<q.Size()<<endl;
}
int main()
{
    Test();
    return 0;
}

3、使用模板的模板参数来封装

# include<stdio.h>
# include<stdlib.h>
# include<assert.h>
# include<string.h>
# include<iostream>
using namespace std;
template<class T, template<class> class Container = List>
//如果带有缺省值也必须为一个模板，"List"
class Queue
{
public:
	//给出空间
	Queue()
	{}
	void Push(const T& data)
	{
		_con.PushBack(data);
	}
	void Pop()
	{
		_con.PopFront();
	}
	T& Front()
	{
		return _con.Front();
	}
	const T& Front()const
	{
		return _con.Front();
	}
	T& Back()
	{
		return _con.Back();
	}
	const T& Back()const
	{
		return _con.Back();
	}
	size_t Size()const
	{
		return _con.Size();
	}
	bool Empty()const
	{
		return _con.Empty();
	}
private:
	Container<T> _con;//通过具体的类型定义一个容器
};
void Test()
{
	Queue<int> q;
	q.Push(1);
	q.Push(2);
	q.Push(3);
	q.Push(4);
	q.Push(5);
	cout << q.Front() << endl;
	cout << q.Back() << endl;
	cout << q.Size() << endl;
	q.Pop();
	q.Pop();
	q.Pop();
	cout << q.Front() << endl;
	cout << q.Back() << endl;
	cout << q.Size() << endl;
}
int main()
{
	Test();
	return 0;
}