2022/8/30——手动实现c++中的stack类

stack类为容器适配器，它给予程序员栈的功能，存储数据特性为先进后出。

类的定义

template <typename T>
class MyStack
{
private:
    T *first;
    T *last;
    int len;      //栈中成员的个数

public:
    函数代码
}

类中包含四大基本函数——析构函数、构造函数、拷贝构造函数、拷贝赋值函数

 析构函数

    MyStack()
    {
        first = new T[1];
        last = first;         //说明为空
        len = 0;
    }

构造函数

    ~MyStack()
    {
        delete []first;
        first = last = NULL;
    }

拷贝构造函数

    MyStack(const MyStack &other)
    {
        this->len = other.len;
        this->first = new T[other.len+1];
        memcpy(this->first,other.first,other.len*sizeof (T));
    }

拷贝赋值函数

    MyStack &operator=(const MyStack &other)
    {
        int size = other.len+1;
        T *temp = new T[size];
        memcpy(temp,other.first,size*sizeof(T));
        delete []this->first;
        this->len = size-1;
        this->first = temp;
        this->last = this->first+size-1;
        return *this;
    }

公有成员函数

1、判空

    bool empty()
    {
        return this->first == this->last;
    }

 2、入栈

    void push(const T val)
    {
        int size = len+1;      //取出队列的长度（包括last指向的待入列）
        *last = val;          //将数据入列
        T *temp = new T[size+1];    //申请新的空间存放队列并留出一个空间
        memcpy(temp,this->first,size*sizeof(T));
        delete []first;   //删除旧队列
        //改变指针的指向
        first = temp;
        last = first + size;
        len++;
    }

3、出栈

    void pop()
    {
        if(this->empty())
        {
            cout<<"栈空，出栈失败"<<endl;
            return;
        }
        int size = len;
        T *temp = new T[size];
        memcpy(temp,this->first,size*sizeof(T));
        delete []first;
        first = temp;
        last = first + size-1;
        len--;
    }

4、获取特定位置的元素

    T &at(int index)
    {
        if(index<0 || index>len)
        {
            cout<<"访问越界"<<endl;
        }
        return first[index];
    }

完整代码（包含功能的测试）

#include <iostream>

using namespace std;

template <typename T>
class MyStack
{
private:
    T *first;
    T *last;
    int len;

public:
    MyStack()
    {
        first = new T[1];
        last = first;         //说明为空
        len = 0;
    }
    //析构函数
    ~MyStack()
    {
        delete []first;
        first = last = NULL;
    }

    //拷贝构造函数
    MyStack(const MyStack &other)
    {
        this->len = other.len;
        this->first = new T[other.len+1];
        memcpy(this->first,other.first,other.len*sizeof (T));
    }

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

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

    //入栈
    void push(const T val)
    {
        int size = len+1;      //取出队列的长度（包括last指向的待入列）
        *last = val;          //将数据入列
        T *temp = new T[size+1];    //申请新的空间存放队列并留出一个空间
        memcpy(temp,this->first,size*sizeof(T));
        delete []first;   //删除旧队列
        //改变指针的指向
        first = temp;
        last = first + size;
        len++;
    }

    //出栈
    void pop()
    {
        if(this->empty())
        {
            cout<<"栈空，出栈失败"<<endl;
            return;
        }
        int size = len;
        T *temp = new T[size];
        memcpy(temp,this->first,size*sizeof(T));
        delete []first;
        first = temp;
        last = first + size-1;
        len--;
    }
    //获取特定位置的元素
    T &at(int index)
    {
        if(index<0 || index>len)
        {
            cout<<"访问越界"<<endl;
        }
        return first[index];
    }

    int size()
    {
        return len;
    }
};

int main()
{
    MyStack<int> v;
    for(int i=1; i<=20; i++)
    {
        v.push(i);
    }
    MyStack<int> v2=v;
    for(int i=0; i<20; i++)
    {
        cout<<v.at(i)<<" ";
    }
    cout<<endl;
    for(int i=0; i<20; i++)
    {
        cout<<v2.at(i)<<" ";
    }
    cout<<endl;
    for(int i=0; i<10; i++)
    {
        v.pop();
    }
    for(int i=0; i<10; i++)
    {
        cout<<v.at(i)<<" ";
    }
    cout<<endl;
    return 0;
}