Simulation of stack and queue

stack The main member variable of

stack Is an adapter container .
Adapter ： Create a new container from an existing container , For example vector Can be realized stack.
We don't use it directly here vector, Instead, a template is used Container, In this way, we can pass different containers to achieve stack（ The default container is deque）, This is not limited to the use of vector To achieve .

	template<class T,class Container=deque<T>>
	class stack
	{
    
	public:
	// Various member functions 
	//....
	private:
		//vector<T> _CON;// Don't write directly vector, If you write like this , You can only implement the array stack , We should write a template parameter , This allows you to pass in different containers , Implement different stacks 
		Container _con;// Write constructor for , Custom types call default constructors .
	};

empty

Judge stack Is it empty

		bool empty()const
		{
    
			return _con.empty();
		}

size

return stack Size

	size_t size()const
		{
    
			return _con.size();
		}

push

Insert an element , the reason being that stack, So call _con Tail interpolation method of

		void push(const T& val)
		{
    
			_con.push_back(val);
		}

top

Back to top of stack element

		const T& top()const
		{
    
			return _con.back();
		}

pop

Out of the stack

		void pop()
		{
    
			_con.pop_back();
		}

queue The main member variable of

queue It is also an adapter container , The container used is also a template parameter , Default transmission deque.

template<class T,class Container=deque<T>>
	class queue
	{
    
	public:
	
	// Various member functions 
	//........
	
	private:
		Container _con;
	};

queue The simulation implementation and stack similar , Here we will give the whole code directly .

	template<class T,class Container=deque<T>>
	class queue
	{
    
	public:
		bool empty() const 
		{
    
			return _con.empty();
		}

		size_t size()const
		{
    
			return _con.size();
		}

		const T& front()const
		{
    
			return _con.front();
		}

		const T& back() const
		{
    
			return _con.back();
		}

		void push(const T& x)
		{
    
			_con.push_back(x);
		}

		void pop()
		{
    
			_con.pop_front();
		}



	private:
		Container _con;
	};