stack 模板类与queue 模板类

stack 模板类

#include <iostream>


using namespace std;

template<typename T>
class MySta
{
private:
    T* top1;
    T* end1;
public:
    //构造函数
    MySta(int size=1)
    {
        top1=new T[size];
        end1=top1;  说明为空
    }

    //析构函数
    ~MySta()
    {
        delete []end1;
        top1=end1=NULL;
    }

    //返回容纳的元素数
    int size()
    {
        return top1-end1;
    }



    //拷贝构造函数
    MySta(const MySta& other)
    {
        //先计算出原空间的尺寸
        int size=other.size()+1;
        int len=size-1;

        end1=new T[size];//新对象的容量
        memcpy(end1,other.end1,len*sizeof(T));

        //将该对象的last指针指向对应位置
        top1=end1+len;
    }

    //拷贝赋值函数
    MySta& operator=(const MySta& other)
    {
        int size=other.size()+1;
        T *temp=new T[size];
        memcpy(temp,other.end1,size*sizeof(T));
        delete []end1;
        end1=temp;
        top1=end1+size;
    }

    //访问栈顶元素
    T top()const
    {
        return *(top1-1);
    }




    //判空
    bool empty()
    {
        return top1==end1;
    }


    //向队列尾部插入元素
    void push(const T val)
    {
        int size=this->size()+1;
        T* temp=new T[size];
        memcpy(temp,end1,(size-1)*sizeof(T));
        delete []end1;
        end1=temp;
        top1=end1+size-1;
        *top1=val;
        top1++;
    }

    //删除首个元素
    void pop()
    {
        if(empty())
        {
            cout<<"栈表空"<<endl;
            return;
        }
        top1--;

        int size=this->size();
        T* temp=new T[size];
        memcpy(temp,end1,size*sizeof(T));
        delete []end1;
        end1=temp;
        top1=end1+size;
    }



};

int main()
{
    MySta<int> q1;
    cout<<q1.size()<<endl;

    for(int i=0;i<20;i++)
    {
        q1.push(i);
        cout<<q1.size()<<endl;
    }
    while(!(q1.empty()))
    {
        cout<<q1.top()<<" ";
        q1.pop();
    }



    return 0;
}

queue 模板类

#include <iostream>


using namespace std;

template<typename T>
class MyQue
{
private:
    T* first;
    T* last;
public:
    //构造函数
    MyQue(int size=1)
    {
        first=new T[size];
        last=first;  说明为空
    }

    //析构函数
    ~MyQue()
    {
        delete []first;
        first=last=NULL;
    }

    //返回容纳的元素数
    int size()
    {
        return last-first;
    }



    //拷贝构造函数
    MyQue(const MyQue& other)
    {
        //先计算出原空间的尺寸
        int size=other.size()+1;
        int len=size-1;

        first=new T[size];//新对象的容量
        memcpy(first,other.first,len*sizeof(T));

        //将该对象的last指针指向对应位置
        last=first+len;
    }

    //拷贝赋值函数
    MyQue& operator=(const MyQue& other)
    {
        int size=other.size()+1;
        T *temp=new T[size];
        memcpy(temp,other.first,size*sizeof(T));
        delete []first;
        first=temp;
        last=first+size;
    }

    //访问第一个元素
    T front()const
    {
        return *first;
    }

    //访问最后一个元素
    T back()const
    {
        return *last;
    }


    //判空
    bool empty()
    {
        return last==first;
    }


    //向队列尾部插入元素
    void push(const T val)
    {
        int size=this->size()+1;
        T* temp=new T[size];
        memcpy(temp,first,(size-1)*sizeof(T));
        delete []first;
        first=temp;
        last=first+size-1;
        *last=val;
        last++;
    }

    //删除首个元素
    void pop()
    {
        if(empty())
        {
            cout<<"栈表空"<<endl;
            return;
        }

        first++;

        int size=this->size();
        T* temp=new T[size];
        memcpy(temp,first,size*sizeof(T));
        delete []first;
        first=temp;
        last=first+size;
    }



};

int main()
{
    MyQue<int> q1;
    cout<<q1.size()<<endl;

    for(int i=0;i<20;i++)
    {
        q1.push(i);
        cout<<q1.size()<<endl;
    }
    while(!(q1.empty()))
    {
        cout<<q1.front()<<" ";
        q1.pop();
    }


    return 0;
}