模版和智能指针

#ifndef SEQLIST_H
#define SEQLIST_H

#include <iostream>
#include <algorithm> // for std::sort
using namespace std;

template <typename T>
class Seqlist {
private:
    T *ptr; // 动态数组指针
    int size; // 数组的最大容量
    int len = 0; // 当前元素个数

public:
    // 初始化顺序列表
    void init(int n) {
        size = n;
        ptr = new T[size]; // 动态分配内存
        len = 0; // 初始化长度为0
    }

    // 检查是否为空
    bool empty() {
        return len == 0;
    }

    // 检查是否已满
    bool full() {
        return len >= size;
    }

    // 在末尾添加元素
    void push_back(T n) {
        if (!full()) {
            ptr[len++] = n; // 添加元素并更新长度
        } else {
            cout << "List is full!" << endl;
        }
    }

    // 显示所有元素
    void show() {
        for (int i = 0; i < len; i++) {
            cout << ptr[i] << " ";
        }
        cout << endl;
    }

    // 在指定位置插入元素
    void insert(T n, int m) {
        if (m < 0 || m > len || full()) {
            cout << "Invalid position or list is full!" << endl;
            return;
        }
        for (int i = len; i > m; i--) {
            ptr[i] = ptr[i - 1]; // 移动元素
        }
        ptr[m] = n; // 插入新元素
        len++;
    }

    // 删除指定位置的元素
    void erase(int n) {
        if (n < 0 || n >= len) {
            cout << "Invalid position!" << endl;
            return;
        }
        for (int i = n; i < len - 1; i++) {
            ptr[i] = ptr[i + 1]; // 移动元素
        }
        len--; // 更新长度
    }

    // 删除最后一个元素
    void pop_back() {
        if (!empty()) {
            len--; // 更新长度
        } else {
            cout << "List is empty!" << endl;
        }
    }

    // 获取当前大小
    void findsize() {
        cout << "Current size: " << len << endl;
    }

    // 获取指定位置的元素
    void at(int n) {
        if (n < 0 || n >= len) {
            cout << "Invalid position!" << endl;
            return;
        }
        cout << "Element at position " << n << ": " << ptr[n] << endl;
    }

    // 排序
    void sort(bool flag) {
        if (flag) {
            std::sort(ptr, ptr + len); // 升序排序
        } else {
            std::sort(ptr, ptr + len, greater<T>()); // 降序排序
        }
    }

    // 析构函数
    ~Seqlist() {
        delete[] ptr; // 释放动态分配的内存
    }
};

#endif // SEQLIST_H

栈的模版类

#include <iostream>

using namespace std;

template <typename T>
class zhan {
private:
    static const int size = 100; // 栈的最大容量
    T data[size]; // 存储数据的数组
    int top; // 栈顶指针

public:
    zhan() : top(0) {} // 构造函数，初始化栈顶指针

    // 入栈
    void push(T value) {
        if (top >= size) {
            cout << "Stack overflow!" << endl; // 栈满
            return;
        } else {
            data[top++] = value; // 将值压入栈中
        }
    }

    // 检查栈是否为空
    bool empty() {
        return top == 0;
    }

    // 出栈
    void back() {
        if (empty()) {
            cout << "Stack is empty!" << endl; // 栈空
            return;
        } else {
            top--; // 移除栈顶元素
        }
    }

    // 显示栈顶元素
    void topshow() {
        if (empty()) {
            cout << "Stack is empty!" << endl; // 栈空
            return;
        }
        cout << data[top - 1] << endl; // 输出栈顶元素
    }

    // 显示当前栈的大小
    void big() {
        cout << top << endl;
    }

    // 交换栈中两个元素
    void swap(int m, int n) {
        if (m < 0 || m >= top || n < 0 || n >= top) {
            cout << "Invalid index!" << endl; // 索引无效
            return;
        }
        T temp = data[m];
        data[m] = data[n];
        data[n] = temp;
    }

    // 显示栈中的所有元素
    void show() {
        for (int i = 0; i < top; i++) {
            cout << data[i] << endl;
        }
    }

    // 重载 += 运算符
    zhan &operator+=(const zhan &other) {
        int max = (top < other.top) ? other.top : top; // 取较大栈的大小
        this->top = max; // 更新当前栈的大小
        for (int i = 0; i < max; i++) {
            this->data[i] += other.data[i]; // 元素相加
        }
        return *this;
    }
};

int main() {
    zhan<int> s1; // 创建整型栈
    s1.push(3);
    s1.push(1);
    s1.push(7);
    s1.push(0);
    s1.show();
    s1.topshow();

    zhan<int> s2; // 创建整型栈
    s2.push(3);
    s2.push(1);
    s2.push(7);
    s2.push(9);
    s2.push(9);
    s2.push(9);
    s2.push(9);
    s2.push(9);
    s2.show();

    s1 += s2; // 使用重载的 += 运算符
    s1.show();

    return 0;
}