Stack顺序栈(C++实现)

前言

大家好我是東木,在CSDN上持续更新更多原创文章，唯一指定传送门：東木的博客

本文将分享一下自己用C++实现myStack类（数组）。其private部分包括一个记录数组大小变量m_bufferSize，还有一个T类型的指针，有一个m_top记录栈顶，常量onceAlloc为一次分配时候的空间大小。在此Header file中，在本文我不采取C++的异常机制。程序有不足的地方还请大家多多指正！

代码块

//
// Created by dongMu on 2020/9/29.
//

#ifndef _myStack_H
#define _myStack_H

#include "bits/stdc++.h"
#include <ciso646>

using namespace std;

template<class T>
class myStack {
private:
    T *ptr_data;//指向一块内存空间的指针
    int m_bufferSize;//buffer的大小
    int m_top;//栈顶位置
    const int onceAlloc;//达到某个特定条件后，重新多余分配的空间大小
public:
    //构造函数
    myStack(int new_bufferSize = 0);

    //拷贝构造函数
    myStack(const myStack<T> &stack);

    //拷贝赋值
    myStack<T> &operator=(const myStack<T> &stack);

    //析构函数
    ~myStack();

    //入栈
    bool push(T const &val);

    //出栈
    bool pop();

    //判断空
    inline bool is_empty() const{ return (m_top == 0); }

    //判断满
    inline bool is_full() const{ return (m_bufferSize == m_top); }

    //只读栈的长度1
    inline int size() const{
        cout << m_top << endl;
        return m_top;
    }

    //只读栈的长度2
    inline int length() const{
        cout << m_top << endl;
        return m_top;
    }

    //只读栈顶元素
    inline T get_top() const{
        if (!is_empty()){
            cout << ptr_data[m_top-1] << endl;
            return ptr_data[m_top-1];
        }
    }

    //只读m_bufferSize
    inline int get_bufferSize()const{
        cout<<m_bufferSize<<endl;
        return m_bufferSize;
    }

    //摧毁栈
    inline bool destroy() {
        delete this;
        return true;
    }

};

template<class T>
inline
myStack<T>::myStack(int new_bufferSize):ptr_data(nullptr), m_bufferSize(new_bufferSize), m_top(0), onceAlloc(10) {
    if (m_bufferSize < 0) {
        cout << "m_bufferSize不可小于0";

    } else {
        //申请一块空间
        ptr_data = new T[m_bufferSize];
    }

}

template<class T>
inline myStack<T>::myStack(const myStack<T> &stack1):ptr_data(nullptr), m_bufferSize(stack1.m_bufferSize), m_top(stack1.m_top), onceAlloc(10) {

    ptr_data = new T[m_bufferSize];
    //将原来的复制到新的空间去
    memcpy(ptr_data, stack1.ptr_data, stack1.m_top * sizeof(T));

}

template<class T>
inline myStack<T> &myStack<T>::operator=(const myStack<T> &stack1) {
    if (this == &stack1) {
        return *this;
    } else {
        //清除ptr_data原来所指的空间
        delete[]ptr_data;
        m_bufferSize = stack1.m_bufferSize;
        this->m_top = stack1.m_top;
        ptr_data = new T[m_bufferSize];
        //将原来的复制到新的空间去
        memcpy(ptr_data, stack1.ptr_data, stack1.m_top * sizeof(T));
    }
    return *this;
}

template<class T>
inline myStack<T>::~myStack() {
    //摧毁原来ptr_data指针所指的空间
    delete[]ptr_data;
    //指针指向空
    ptr_data = nullptr;
}

template<class T>
bool myStack<T>::push(const T &val) {

    if (m_top < m_bufferSize) {
        //入栈
        ptr_data[m_top++] = val;
    } else {
        //重新申请空间
        T *new_ptr_data = new T[m_bufferSize + onceAlloc];
        //将原来的复制到新的空间去
        memcpy(new_ptr_data, ptr_data, m_top * sizeof(T));
        //m_bufferSize扩增
        m_bufferSize = m_top + onceAlloc;
        //入栈
        new_ptr_data[m_top++] = val;
        //摧毁原来ptr_data指针所指的空间
        delete[]ptr_data;
        //ptr_data和new_ptr_data指向同一个地方，函数结束后，new_ptr_data临时变量的生命将结束
        ptr_data = new_ptr_data;
    }

    return true;
}

template<class T>
bool myStack<T>::pop() {
    if (--m_top == m_bufferSize - onceAlloc) {
        //m_bufferSize变化
        m_bufferSize = m_bufferSize  - onceAlloc;
        //重新申请空间
        T *new_ptr_data = new T[m_bufferSize];
        //将原来的复制到新的空间去
        memcpy(new_ptr_data, ptr_data, m_top * sizeof(T));

        delete[]ptr_data;
        //ptr_data和new_ptr_data指向同一个地方，函数结束后，new_ptr_data临时变量的生命将结束
        ptr_data = new_ptr_data;
    } else {
        ptr_data[m_top+1]=0;
    }

    return true;
}


#endif //_myStack_H

参考资料

1.用C++实现Stack堆栈
2.侯捷高级OOP