模拟实现容器适配器栈和队列

stack.h

 

#pragma once
#include "Vector.h"
#include <iostream>
using namespace std;
#if 0
//方法一
template<class T>
class stack
{
public:
	stack()
		:_pData(new T[3])
		, size(0)
		, capacity(3)
	{}

	void Push(T& data)
	{
		_CheckCapacity();
		_pData[size++] = data;
	}

	void Pop()
	{
		size--;
	}

	T& top()
	{
		return _pData[size - 1];
	}
	const T& top()const
	{
		return _pData[size - 1];
	}
	size_t Size()const
	{
		return size;
	}
	bool Empty()const
	{
		return size == 0;
	}
private:
	void _CheckCapacity()
	{
		size_t capacity = Capacity();
		size_t size = Size();
		if (size >= capacity)
		{
			T* tmp = new T[capacity * 2 + 3];//开辟新空间

			if (_start != NULL)//拷贝元素
			{
				if (IsPOD(typeid(T).name()))//内置类型
				{
					memcpy(tmp, _pData, size*sizeof(T));
				}
				else//非内置类型
				{
					for (size_t i = 0; i < size; ++i)
					{
						tmp[i] = _pData[i];
					}
				}
			}

			if (_pData)
				delete[] _pData;

			_pData = tmp;
			capacity = capaticy * 2 + 3;
		}
	}
	bool IsPOD(const char* Typename)
	{
		static char*p[] = { "int", "double", "float", "char", "long", "long long" };
		for (size_t i = 0; i < 6; ++i)
		{
			if ((strcmp(p[i], Typename)) == 0)
				return true;
		}
		return false;
	}
private:
	T* _pData;
	size_t size;
	size_t capacity;

};
#endif

#if 0
//方法二
template<class T,class Container>
class Stack
{
public:
	Stack()
	{}

	void Push(const T& data)
	{
		_c.PushBack(data);
	}

	void Pop()
	{
		_c.PopBack();
	}

	size_t Size()const
	{
		return _c.Size();
	}

	T& Top()
	{
		return _c.Back();
	}

	const T& Top()const
	{
		return _c.Back();
	}
private:
	Container _c;
};
#endif

#if 0
//模板的模板参数
template<class T,template<class >Container=Vector>//第二个参数的参数是第一个，只能有一个参数
class Stack
{
public:
	Stack()
	{}

	void Push(const T& data)
	{
		_c.PushBack(data);
	}

	void Pop()
	{
		_c.PopBack();
	}

	size_t Size()const
	{
		return _c.Size();
	}

	bool Empty()const
	{
		return _c.Empty();
	}

	T& Top()
	{
		return _c.Back();
	}

	const T& Top()const
	{
		return _c.Back();
	}
private:
	Container<T> _c;
};
#endif 
//库
#include <vector>

template<class T,class Container = vector<T>>
class Stack
{
public:
	Stack()
	{}

	void Push(const T& data)
	{
		_c.push_back(data);
	}

	void Pop()
	{
		_c.pop_back();
	}

	size_t Size()const
	{
		return _c.size();
	}

	bool Empty()const
	{
		return _c.empty();
	}

	T& Top()
	{
		return _c.back();
	}

	const T& Top()const
	{
		return _c.back();
	}
private:
	Container _c;
};

queue.h

 

 

#pragma once
#include "List.h"

template<class T,class Containter=List<T>>
class Queue
{
public:
	Queue()
	{}

	void Push(const T& data)//尾插
	{
		_c.PushBack(data);
	}
	void Pop()//头删
	{
		_c.PopFront();
	}
	size_t Size()const
	{
		return _c.Size();
	}
	bool Empty()const
	{
		return _c.Empty();
	}
	T& Front()
	{
		return _c.Front();
	}
	const T& Front()const
	{
		return _c.Front();
	}
	T& Back()
	{
		return _c.Back();
	}
	const T& Back()const
	{
		return _c.Back();
	}
private:
	Containter _c;

};

Array.h

 

 

#pragma once


template<class T,size_t N>
class Array
{
public:
	typedef T* Interator;
public:
	Array()
		: size(0)
	{}
	void PushBack(const T& data)
	{
		/*_CheckCapacity();*/
		array[size++] = data;
	}
	void PopBack()
	{
		if (Empty())
			return;
		--size;
	}
	size_t Size()const
	{
		return size;
	}
	size_t Capaticy()const
	{
		return N;
	}
	bool Empty()const
	{
		return 0 == N;
	}
	T& operator[](const size_t index)
	{
		return array[index];
	}
	const T& operator[](const size_t index)const
	{
		return array[index];
	}

	Interator
	Interator Begin()
	{
		T* start = array;
		return start;
	}

	Interator End()
	{
		T* tmp = array;
		for (size_t i = 0; i < size; ++i)
		{
			tmp++;
		}
		return tmp;
	}
private:
	T array[N];
	size_t size;
	size_t capacity;
};