量化交易之算法篇 - 用数组自定义栈容器

// Stack.h

#ifndef ALPHAPROJECT_STACK_H
#define ALPHAPROJECT_STACK_H

#include <iostream>

//template<class T>
class Stack {

public:
    explicit Stack(size_t capacity);
    ~Stack();

    void push(double value);
    double pop();

    double *top();

    size_t size() const;
    bool empty() const;

private:
    void reset(size_t capacity);

private:
    double* m_data;

    size_t m_capacity; // stack 容量
    size_t m_size; // stack 元素个数

};

#endif //ALPHAPROJECT_STACK_H

// Stack.cpp

#include "Stack.h"

#include <iostream>
using namespace std;

Stack::Stack(size_t capacity): m_size(0), m_capacity(capacity) {
    this->m_data = new double[this->m_capacity];
    for(size_t index = 0; index < this->m_capacity; index++) {
        this->m_data[index] = 0;
    }
}

Stack::~Stack() {
    if (this->m_data) {
        delete[] this->m_data;
        this->m_data = nullptr;
    }
}

void Stack::push(double value) {
    if (this->m_size == this->m_capacity)
        this->reset(this->m_capacity+10);

    this->m_data[this->m_size] = value;
    this->m_size++;
}

double Stack::pop() {
    if (!this->empty()) {
        this->m_size--;
        return this->m_data[this->m_size];
    }

    return 0;
}

double *Stack::top() {
    if (!this->m_size)
        return nullptr;

    return m_data + this->m_size - 1;
}

size_t Stack::size() const {
    return this->m_size;
}

bool Stack::empty() const {
    return (0 == this->m_size);
}


void Stack::reset(size_t capacity){
    this->m_capacity = capacity;

    auto* data = new double[this->m_capacity];
    for (size_t index = 0; index < this->m_capacity; index++) {
        if (index < this->m_size) {
            data[index] = this->m_data[index];
        } else {
            data[index] = 0;
        }
    }
    delete[] this->m_data;

    this->m_data = data;
}