C++模版类实现栈

text.h

#ifndef TEXT_H
#define TEXT_H


#include <stdexcept> // 用于 std::out_of_range

template <typename T>
class MyStack {
private:
    T* data;         // 指向底层数组的指针
    int capacity;    // 容量
    int top;         // 栈顶索引
    int size;        // 当前元素数量

    void resize(int new_capacity); // 扩容函数

public:
    // 无参构造函数
    MyStack();

    // 有参构造函数
    MyStack(int initial_capacity);

    // 拷贝构造函数
    MyStack(const MyStack& other);

    // 赋值运算符
    MyStack& operator=(const MyStack& other);

    // 析构函数
    ~MyStack();

    // 访问第一个元素
    T& front();

    // 访问最后一个元素
    T& back();

    // 检查栈是否为空
    bool is_empty() const;

    // 返回栈的元素数量
    int get_size() const;

    // 尾插
    void push(const T& value);

    // 尾删
    void pop();

    // 在尾部原位置构造元素
    template<typename... Args>
    void emplace_back(Args&&... args);

    // 删除首个元素
    void pop_front();

    // 交换内容
    void swap(MyStack& other);
  
};

#include "text.cpp" // 包含实现文件


#endif // TEXT_H

text.cpp

#include "text.h"



// 无参构造函数
template <typename T>
MyStack<T>::MyStack() : capacity(10), top(-1), size(0) {
    data = new T[capacity]; // 动态分配初始容量
}

// 有参构造函数
template <typename T>
MyStack<T>::MyStack(int initial_capacity) : capacity(initial_capacity), top(-1), size(0) {
    data = new T[capacity]; // 动态分配指定容量
}

// 拷贝构造函数
template <typename T>
MyStack<T>::MyStack(const MyStack& other) : capacity(other.capacity), top(other.top), size(other.size) {
    data = new T[capacity]; // 动态分配新数组
    for (int i = 0; i <= top; i++) {
        data[i] = other.data[i]; // 复制元素
    }
}

// 赋值运算符
template <typename T>
MyStack<T>& MyStack<T>::operator=(const MyStack& other) {
    if (this != &other) { // 防止自赋值
        delete[] data; // 释放原有内存
        capacity = other.capacity;
        top = other.top;
        size = other.size;
        data = new T[capacity]; // 动态分配新数组
        for (int i = 0; i <= top; i++) {
            data[i] = other.data[i]; // 复制元素
        }
    }
    return *this; // 返回当前对象
}

// 析构函数
template <typename T>
MyStack<T>::~MyStack() {
    delete[] data; // 释放动态分配的内存
}

// 访问第一个元素
template <typename T>
T& MyStack<T>::front() {
    if (is_empty()) {
        throw std::out_of_range("Stack is empty");
    }
    return data[0]; // 返回第一个元素
}

// 访问最后一个元素
template <typename T>
T& MyStack<T>::back() {
    if (is_empty()) {
        throw std::out_of_range("Stack is empty");
    }
    return data[top]; // 返回最后一个元素
}

// 检查栈是否为空
template <typename T>
bool MyStack<T>::is_empty() const {
    return size == 0; // 如果元素数量为0，返回true
}

// 返回栈的元素数量
template <typename T>
int MyStack<T>::get_size() const {
    return size; // 返回当前元素数量
}

// 尾插
template <typename T>
void MyStack<T>::push(const T& value) {
    if (size >= capacity) {
        resize(capacity * 2); // 扩容为原来的两倍
    }
    data[++top] = value; // 插入新元素
    size++; // 更新元素数量
}

// 尾删
template <typename T>
void MyStack<T>::pop() {
    if (is_empty()) {
        throw std::out_of_range("Stack is empty");
    }
    top--; // 移除栈顶元素
    size--; // 更新元素数量
}

// 在尾部原位置构造元素
template <typename T>
template<typename... Args>
void MyStack<T>::emplace_back(Args&&... args) {
    if (size >= capacity) {
        resize(capacity * 2); // 扩容为原来的两倍
    }
    data[++top] = T(std::forward<Args>(args)...); // 原位置构造元素
    size++; // 更新元素数量
}

// 删除首个元素
template <typename T>
void MyStack<T>::pop_front() {
    if (is_empty()) {
        throw std::out_of_range("Stack is empty");
    }
    for (int i = 0; i < top; i++) {
        data[i] = data[i + 1]; // 移动元素
    }
    top--; // 移除首个元素
    size--; // 更新元素数量
}

// 交换内容
template <typename T>
void MyStack<T>::swap(MyStack& other) {
    std::swap(data, other.data);
    std::swap(capacity, other.capacity);
    std::swap(top, other.top);
    std::swap(size, other.size);
}

// 扩容函数
template <typename T>
void MyStack<T>::resize(int new_capacity) {
    T* new_data = new T[new_capacity]; // 动态分配新数组
    for (int i = 0; i <= top; i++) {
        new_data[i] = data[i]; // 复制旧数据
    }
    delete[] data; // 释放旧内存
    data = new_data; // 更新指针
    capacity = new_capacity; // 更新容量
}

main.cpp

#include <iostream>
#include "text.h"

using namespace std;

int main() {
    MyStack<double> stack; // 创建一个整型栈

    // 尾插元素
    stack.push(99.99);
    stack.push(10.11);
    stack.push(88.88);
    stack.push(66.66);
    std::cout << "输出最后一个元素 " << stack.back() << std::endl;
    std::cout << "输出第一个元素 " << stack.front() << std::endl;
    std::cout << "输出长度 " << stack.get_size() << std::endl;

    // 删除首个元素
    stack.pop_front();
    std::cout << "输出删除后的第一个元素 " << stack.front() << std::endl;

    // 尾删元素
    stack.pop();
    std::cout << "删除后的最后一个元素 " << stack.back() << std::endl; 

    // 交换内容
    MyStack<double> stack2;
    stack2.push(4.99);
    stack2.push(1.11);
    stack.swap(stack2);
    std::cout << "输出交换后的stack的最后一个元素 " << stack.back() << std::endl; 
    std::cout << "输出交换后的stack2的最后一个元素 " << stack2.back() << std::endl; 

    return 0;
}