C++day4

手动实现顺序栈，要求实现数据结构中，所有栈的相关操作

#include <iostream>
#include<cstring>
#include<sstream>
 
using namespace std;
template <typename T>
 
class myVector
{
private:
    T *first; // 指向第一个元素的指针
    T *last; // 指向最后一个实际元素的指针
    T *end; // 指向可用空间的尾后指针
public:
    myVector():first(nullptr),last(nullptr),end(nullptr) {} //默认构造函数
        myVector(int n, const T& val) //构造函数，初始化n个值为val的元素
        {
            first=new T[n];
            end=first+n;
            last=first+n;
            for(T *p=first;p!=last;p++)
            {
                *p=val;
            }
        }
        myVector(const myVector& v) //拷贝构造函数
        {
            first=new T[v.capacity()];
            end=first+v.capacity();
            last=first+v.size();
            for (T *p1=first,*p2=v.first;p1!=last;p1++,p2++)
            {
                *p1=*p2;
            }
        }
        ~myVector() //析构函数
        {
            delete[] first;
        }
        myVector &operator=(const myVector& v) //拷贝赋值
        {
            if(this==&v)
            {
                return *this;
            }
            delete[] first;
            first=new T[v.capacity()];
            end=first+v.capacity();
            last=first+v.size();
            for(T *p1=first,*p2=v.first;p1!=last;p1++,p2++)
            {
                *p1=*p2;
            }
            return *this;
        }
        T &at(int index) const //获取指定位置的元素，并进行边界检查
        {
            if(index<0||index>=size())
            {
                throw out_of_range("Index out of range");
            }
            return *(first+index);
        }
        bool empty() const //判断向量是否为空
        {
            return size()==0;
        }
        bool full() const //判断向量是否已满
        {
            return size()==capacity();
        }
        T &front() const  //获取向量首元素
        {
            if(!empty())
            {
                return *first;
            }
            throw out_of_range("Vector is empty");
        }
        T &back() const //获取向量尾元素
        {
            if(!empty())
            {
                return *(last-1);
            }
            throw out_of_range("Vector is empty");
        }
        int size() const //获取当前元素个数
        {
            return last-first;
        }
        int capacity() const //获取当前可用空间大小
        {
            return end-first;
        }
        void clear() //清除所有元素
        {
            for(T *p=first;p!=last;p++)
            {
                p->~T();
            }
            last=first;
        }
        void expand() //二倍扩容函数
        {
            int old_capacity=capacity();
            int new_capacity=old_capacity==0?1:old_capacity*2;
            T *new_first=new T[new_capacity];
            T *new_last=new_first+size();
            T *new_end=new_first+new_capacity;
            for(T *p1=new_first,*p2=first;p1!=new_last;p1++,p2++)
            {
                new(p1) T(*p2);
            }
            clear();
            delete[] first;
            first=new_first;
            last=new_last;
            end=new_end;
        }
        void push_back(const T& val) //在向量末尾添加一个元素
        {
            if(full())
            {
                expand();
            }
            new(last) T(val);
            last++;
        }
        void pop_back() //删除向量末尾的一个元素
        {
            if(!empty())
            {
                (last-1)->~T();
                last--;
            }
        }
};
 
int main()
{
    myVector<int> v1; // 默认构造函数
    myVector<int> v2(5,1); // 初始化5个值为1的元素
    myVector<int> v3(v2); // 拷贝构造函数
    v1=v2; // 拷贝赋值
    try
    {
        cout<<"At: "<<v1.at(0)<<endl; //获取指定位置的元素，并进行边界检查
    }
    catch(out_of_range e)
    {
        cout<<e.what()<<endl;
    }
    cout<<"Is empty: "<<v1.empty()<<endl; //判断向量是否为空
    cout<<"Is full: "<<v1.full()<<endl; //判断向量是否已满
    cout<<"Front: "<<v1.front()<<endl; //获取向量首元素
    cout<<"Back: "<<v1.back()<<endl; //获取向量尾元素
    cout<<"Size: "<<v1.size()<<endl; //获取当前元素个数
    v1.clear(); //清除所有元素
    v1.push_back(1); //在向量末尾添加一个元素
    v1.push_back(2);
    v1.push_back(3);
    v1.push_back(4);
    v1.push_back(5);
    v1.push_back(6); //向量已满，二倍扩容
    v1.pop_back(); //删除向量末尾的一个元素
    cout<<"Size: "<<v1.size()<<endl; //获取当前元素个数
    return 0;
}