基于java的数据结构学习——数组实现的栈以及简单应用C++实现

基于java的数据结构学习——数组实现的栈以及简单应用的 C++ 实现

源码：

 

//
// Created by PC-Saw on 2019/1/3.
//

#ifndef DATA_STRUCTURE_ARRAYSTACK_H
#define DATA_STRUCTURE_ARRAYSTACK_H

#include "Stack.h"
#include "MyArray.h"

template<typename T>
class ArrayStack : public Stack<T> {

private:
    MyArray<T>* array;

public:
    ArrayStack();                                       // 无参构造
    ArrayStack(int capacity);                           // 有参构造
    ~ArrayStack();                                      // 析构函数
    ArrayStack(const ArrayStack<T>& arr);               // 拷贝构造
    ArrayStack<T> &operator= (const ArrayStack<T> arr); // 重载赋值操作符
    MyArray<T> &operator[](int index);                  // 重载[]操作赋

    //友元函数实现 重载输出 << 操作符
    friend ostream & operator << (ostream &out, ArrayStack<T> &obj)
    {
        out << "ArrayStack size = " << obj.getSize() << ", Capacity = " << obj.getCapacity() << endl;
        out << "ArrayStack: [";
        for (int i = 0; i < obj.getSize(); ++i)
        {
            out << obj.array->get(i);
            if (i != obj.getSize() - 1)
                out << ", ";
        }
        out << "] Top";

        return out;
    }

    //友元函数实现 输入 >> 操作符
    friend istream & operator >> (istream &in, ArrayStack<T> &obj)
    {
        for (int i = 0; i < obj.getSize(); ++i) {
            in << obj.array[i];
        }

        if (!in)
        {
            obj = new ArrayStack();
        }
        return in;
    }

    int getCapacity();      // 获取栈容量
    int getSize();          // 获取栈内元素个数
    bool isEmpty();         // 判断栈空
    bool isFull();          // 判断栈满
    void push(T t);         // 元素压入栈
    T pop();                // 元素出栈
    T peek();               // 查看栈顶元素
};

// 无参构造函数
template <typename T>
ArrayStack<T>::ArrayStack(){
    cout << "调用 ArrayStack() 构造" << endl;
    array = new MyArray<T>();
}

// 有参构造
template <typename T>
ArrayStack<T>::ArrayStack(int capacity){
    cout << "调用 ArrayStack(int) 构造" << endl;
    array = new MyArray<T>(capacity);
}

// 析构函数
template <typename T>
ArrayStack<T>::~ArrayStack(){
    cout << "调用析构函数" << endl;
    delete[] array;
    array = nullptr;
}

// 拷贝构造
template <typename T>
ArrayStack<T>::ArrayStack(const ArrayStack<T>& arr){
    cout << "拷贝构造" << endl;
    array = new MyArray<T>(arr.getCapacity());
    array = arr;
}

// 重载赋值操作符
template <typename T>
ArrayStack<T>& ArrayStack<T>::operator= (const ArrayStack<T> arr){

    cout << "调用 = 赋值操作" << endl;
    if (this->array != nullptr){
        delete[] this->array;
        this->array = nullptr;
    }

    this->array = new MyArray<T>(arr.getCapacity());

    for (int i = 0; i < arr.getSize(); ++i) {
        this->array[i] = arr[i];
    }
    return *this;
}

// 重载[]操作赋
template <typename T>
MyArray<T>& ArrayStack<T>::operator[](int index){
    if (index < 0 || index > this->getSize() - 1)
        throw "索引非法！";

    return this->array[index];
}

// 获取栈容量
template <typename T>
int ArrayStack<T>::getCapacity(){
    return array->getCapacity();
}

// 获取栈内元素个数
template <typename T>
int ArrayStack<T>::getSize(){
    return array->getSize();
}

// 判断栈空
template <typename T>
bool ArrayStack<T>::isEmpty(){
    return array->isEmpty();
}

// 判断栈满
template <typename T>
bool ArrayStack<T>::isFull(){
    return array->isFull();
}

// 元素压入栈
template <typename T>
void ArrayStack<T>::push(T t){
    array->pushBack(t);
}

// 元素出栈
template <typename T>
T ArrayStack<T>::pop(){
    return array->removeBack();
}

// 查看栈顶元素
template <typename T>
T ArrayStack<T>::peek(){
    return array->getBack();
}

#endif //DATA_STRUCTURE_ARRAYSTACK_H