【C++】简易栈的实现

已于 2023-03-20 14:02:20 修改
阅读量439 收藏 2
点赞数
分类专栏： C++ 文章标签： c++ 开发语言 算法
于 2023-03-19 22:31:43 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43634664/article/details/129656662
版权

【C++】简易栈的实现

程序说明

一、博客日期

本文第一次发布
2023年03月19日22点30分
Authors
THDMI

二、引言

简单记录下，模板的使用，目前尚且还有一个问题就是，在重载加法运算符的过程中，使用malloc产生的类要怎么手动释放，目前在主函数好像不能直接free了，不确定它会不会自动析构。

代码主要描述了一个简单的栈，实现的过程，太久没用C++了，算是复习一下，另外模板也是第二次用，重载运算符是第一次用，嗯，之前都完全没用到，虽然看过教程，这次算是动手实践，但是内存泄露还是存在，换成指针后允许手动释放内存，但还是不够优雅。

实际上想加入根据传入的数组初始化栈的，但是想了很久没想出要怎么在未知数组长度情况下，计算一个数组类型的一级指针参数的长度。

因为只是简单记录，而且是栈，所以暂时不写注释了，有两个类，一个是None，用于标识什么都没有，因为模板不允许用void*，另一个是Rt类，用于返回时携带操作成功或失败，以及必要的结果，如果没有结果，应该使用Rt<None>。

版权声明

本工程作品均为本文作者撰写，无其他参考，允许使用在任何场景，作品遵循GPLv3.0开源协议。转载本文请标注出处。

开发环境

一、开发配置

操作系统
Microsoft Windows10 家庭版 20H2

二、开发工具

软件依赖版本类型版本号
LightlyPerson0.7.9

效果演示

具体测试理论效果参考测试部分。
效果

核心代码

一、构造类

（一）默认长度构造

template <typename T> Stack<T>::Stack() {
    this->stack_array = (T*)malloc(sizeof(T) * this->default_stack_len);
    this->len_max = this->default_stack_len;
    this->len = 0;
}

（二）带自扩容构造

template <typename T> Stack<T>::Stack(bool is_auto_expand) {
    this->stack_array = (T*)malloc(sizeof(T) * this->default_stack_len);
    this->len_max = this->default_stack_len;
    this->len = 0;
    this->is_auto_expand = true;
}

（三）带初始长度构造

template <typename T> Stack<T>::Stack(int stack_len) {
    this->stack_array = (T*)malloc(sizeof(T) * stack_len);
    this->len_max = stack_len;
    this->len = 0;
}

（四）析构

template <typename T> Stack<T>::~Stack() {
    if (nullptr == this->stack_array) {
        return;
    }
    free(this->stack_array);
    this->stack_array = nullptr;
}

二、重载运算符

（一）加法重载运算符

  1. 内存泄露版
template <typename T> Stack<T>& Stack<T>::operator+(Stack& stack_add) {
    Stack<T>* new_stack = (Stack<T>*)malloc(sizeof(Stack<T>));
    new_stack->len = 0;
    new_stack->len_max = this->len + stack_add.get_len();
    if (nullptr != new_stack->stack_array) {
        free(new_stack->stack_array);
    }
    new_stack->stack_array = (T*)malloc(sizeof(T) * new_stack->len_max);
    for (int i = 0; i < this->len; i++) {
        new_stack->push(this->stack_array[i]);
    }
    for (int i = 0; i < stack_add.get_len(); i++) {
        new_stack->push(stack_add.stack_array[i]);
    }
    return *new_stack;
}
  1. 手动释放版
template <typename T> Stack<T>* Stack<T>::operator+(Stack& stack_add) {
    Stack<T>* new_stack = (Stack<T>*)malloc(sizeof(Stack<T>));
    new_stack->len = 0;
    new_stack->len_max = this->len + stack_add.get_len();
    if (nullptr != new_stack->stack_array) {
        free(new_stack->stack_array);
    }
    new_stack->stack_array = (T*)malloc(sizeof(T) * new_stack->len_max);
    for (int i = 0; i < this->len; i++) {
        new_stack->push(this->stack_array[i]);
    }
    for (int i = 0; i < stack_add.get_len(); i++) {
        new_stack->push(stack_add.stack_array[i]);
    }
    // You must free the point if you don't need it.
    return new_stack;
}

（二）复合加法重载运算符

template <typename T> Stack<T>& Stack<T>::operator+=(Stack& st) {
    if (nullptr == this->stack_array) {
        return *this;
    }
    if (this->len_max < this->len + st.len) {
        this->len_max += st.len;
    }
    T* temp = (T*)malloc(sizeof(T) * this->len_max);
    for (int i = 0; i < this->len; i++) {
        temp[i] = this->stack_array[i];
    }
    free(this->stack_array);
    this->stack_array = temp;
    temp = nullptr;
    for (int i = 0; i < st.len; i++) {
        this->push(st.stack_array[i]);
    }
    return *this;
}

三、基本操作

（一）入栈

template <typename T> Rt<None> Stack<T>::push(T ele) {
    Rt<None> rt;
    if (this->len_max <= this->len) {
        if (this->is_auto_expand) {
            T *tmp = (T*)malloc(sizeof(T) * (this->len_max + this->default_stack_len));
            this->len_max += this->default_stack_len;
            memcpy(tmp, this->stack_array, this->len * sizeof(T));
            free(this->stack_array);
            this->stack_array = tmp;
        } else {
            rt.flag = false;
            return rt;
        }
    }
    ++this->len;
    this->stack_array[this->len - 1] = ele;
    rt.flag = true;
    return rt;
}

（二）出栈

template <typename T> Rt<int> Stack<T>::pull() {
    Rt<int> rt;
    if (this->len <= 0) {
        rt.flag = false;
        return rt;
    }
    rt.data = this->stack_array[this->len - 1];
    --this->len;
    rt.flag = true;
    return rt;
}

（三）读栈

template <typename T> Rt<int> Stack<T>::read() {
    Rt<int> rt;
    if (this->len <= 0) {
        rt.flag = false;
        return rt;
    }
    rt.data = this->stack_array[len - 1];
    rt.flag = true;
    return rt;
}

（四）获长

template <typename T> int Stack<T>::get_len() {
     return this->len; 
}

（五）打印

template <typename T> void Stack<T>::print() {
    for (int i = 0; i < this->len; i++) {
        std::cout << this->stack_array[i] << "\t";
    }
    std::cout << std::endl;
}

（六）允扩

template <typename T> void Stack<T>::auto_expand_set(bool option) {
    this->is_auto_expand = option;
}

四、测试

（一）测试代码

    Stack<std::string> st1 = Stack<std::string>();
    Stack<std::string> st2 = Stack<std::string>();
    Stack<std::string> st3;
    for (int i = 0; i < 8; i++) {
        st1.push("abc");
    }
    for (int i = 0; i < 12; i++) {
        st2.push("bcd");
    }
    std::cout << "Stack 01: ";
    st1.print();
    std::cout << "\nStack 02: ";
    st2.print();
    st1 += st2;
    std::cout << "\nStack 01: ";
    st1.print();
    st3 = st1 + st2;
    std::cout << "\nStack 03: ";
    st3.print();

（二）应示效果

  1. st1会入栈8个元素，st2会入栈8个元素
  2. 因为st2允许自动扩容，所以还会再入4个元素
  3. st1和st2组合，st1会扩容，st2全部元素会追加在st1末尾
  4. st3将拥有实例，装载有组合后的st1，再次与st2组合

全部代码

#include <cstdlib>
#include <cstring>
#include <iostream>
#include <iterator>

class None {};

template <typename T> class Rt {
  public:
    bool flag;
    T data;
};

template <typename T> class Stack {
  template <typename S> friend void free_stack(Stack<S>* stack_free);
  
  private:
    int default_stack_len = 8;
    bool is_auto_expand = false;
    T* stack_array;
    int len;
    int len_max;

  public:
    Stack();
    Stack(bool is_auto_expand);
    Stack(int stack_len);
    ~Stack();
    // Stack& operator+(Stack& stack_add);
	Stack* operator+(Stack& stack_add);
    Stack& operator+=(Stack& st);
    void auto_expand_set(bool option);
    int get_len();
    void print();
    Rt<None> push(T ele);
    Rt<int> pull();
    Rt<int> read();
};

template <typename T> Stack<T>* Stack<T>::operator+(Stack& stack_add) {
    Stack<T>* new_stack = (Stack<T>*)malloc(sizeof(Stack<T>));
    new_stack->len = 0;
    new_stack->len_max = this->len + stack_add.get_len();
    if (nullptr != new_stack->stack_array) {
        free(new_stack->stack_array);
    }
    new_stack->stack_array = (T*)malloc(sizeof(T) * new_stack->len_max);
    for (int i = 0; i < this->len; i++) {
        new_stack->push(this->stack_array[i]);
    }
    for (int i = 0; i < stack_add.get_len(); i++) {
        new_stack->push(stack_add.stack_array[i]);
    }
    // You must free the point if you don't need it.
    return new_stack;
}

template <typename T> Stack<T>& Stack<T>::operator+=(Stack& st) {
    if (nullptr == this->stack_array) {
        return *this;
    }
    if (this->len_max < this->len + st.len) {
        this->len_max += st.len;
    }
    T* temp = (T*)malloc(sizeof(T) * this->len_max);
    for (int i = 0; i < this->len; i++) {
        temp[i] = this->stack_array[i];
    }
    free(this->stack_array);
    this->stack_array = temp;
    temp = nullptr;
    for (int i = 0; i < st.len; i++) {
        this->push(st.stack_array[i]);
    }
    return *this;
}

template <typename T> Stack<T>::Stack() {
    this->stack_array = (T*)malloc(sizeof(T) * this->default_stack_len);
    this->len_max = this->default_stack_len;
    this->len = 0;
}

template <typename T> Stack<T>::Stack(bool is_auto_expand) {
    this->stack_array = (T*)malloc(sizeof(T) * this->default_stack_len);
    this->len_max = this->default_stack_len;
    this->len = 0;
    this->is_auto_expand = true;
}

template <typename T> Stack<T>::Stack(int stack_len) {
    this->stack_array = (T*)malloc(sizeof(T) * stack_len);
    this->len_max = stack_len;
    this->len = 0;
}

template <typename T> Stack<T>::~Stack() {
    if (nullptr == this->stack_array) {
        return;
    }
    free(this->stack_array);
    this->stack_array = nullptr;
}

template <typename T> void Stack<T>::auto_expand_set(bool option) {
    this->is_auto_expand = option;
}

template <typename T> int Stack<T>::get_len() {
    return this->len;
}

template <typename T> void Stack<T>::print() {
    for (int i = 0; i < this->len; i++) {
        std::cout << this->stack_array[i] << "\t";
    }
    std::cout << std::endl;
}

template <typename T> Rt<None> Stack<T>::push(T ele) {
    Rt<None> rt;
    if (this->len_max <= this->len) {
        if (this->is_auto_expand) {
            T* tmp = (T*)malloc(sizeof(T) *
                                (this->len_max + this->default_stack_len));
            this->len_max += this->default_stack_len;
            memcpy(tmp, this->stack_array, this->len * sizeof(T));
            // for (int i = 0; i < this->len; i ++) {
            //     tmp[i] = this->stack_array[i];
            // }
            free(this->stack_array);
            this->stack_array = tmp;
        } else {
            rt.flag = false;
            return rt;
        }
    }
    ++this->len;
    this->stack_array[this->len - 1] = ele;
    rt.flag = true;
    return rt;
}

template <typename T> Rt<int> Stack<T>::pull() {
    Rt<int> rt;
    if (this->len <= 0) {
        rt.flag = false;
        return rt;
    }
    rt.data = this->stack_array[this->len - 1];
    --this->len;
    rt.flag = true;
    return rt;
}

template <typename T> Rt<int> Stack<T>::read() {
    Rt<int> rt;
    if (this->len <= 0) {
        rt.flag = false;
        return rt;
    }
    rt.data = this->stack_array[len - 1];
    rt.flag = true;
    return rt;
}

template <typename T> void free_stack(Stack<T>* stack_free) {
    stack_free->~Stack();
    free(stack_free);
    stack_free = nullptr;
}

int main() {
    Stack<std::string> st1 = Stack<std::string>();
    Stack<std::string> st2 = Stack<std::string>(true);
    // Stack<std::string> st3;
    Stack<std::string>* st3;
    for (int i = 0; i < 8; i++) {
        st1.push("abc");
    }
    for (int i = 0; i < 12; i++) {
        st2.push("bcd");
    }
    std::cout << "Stack 01: ";
    st1.print();
    std::cout << "\nStack 02: ";
    st2.print();
    st1 += st2;
    std::cout << "\nStack 01: ";
    st1.print();
    st3 = st1 + st2;
    std::cout << "\nStack 03: ";
    st3->print();
    free_stack(st3);
}

结语

多看、多查、多练

参考文献

[1] C++ Primer 第5版 中文版 (Stanley B. Lippman等著，王刚等译)

END

◎天启疯车℡
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
栈的三种实现方式（C++）
weixin_44139651的博客
07-27 667
一、基于deque实现 优点：利用deque动态管理内存，栈的内存无上限，STL中的栈也是基于deque实现的。 template<class T> class MyStack{ deque<T> dq; public: void push(T element){ dq.push_back(element); } void pop(){ assert(!empty()); dq.pop_
C++写一个简单的堆栈类
Gw's 嵌入式学习技术博客
08-18 1808
/*写一个类栈类，要求完成进栈与出栈*/ #include using namespace std; const int MAX=5; //假定栈中最多保存5个数据 //定义名为stack的类，其具有栈功能 class stack { //数据成员
秒，在解答这个C语言题目上，我们都败了
嵌入式Linux
08-25 415
看这篇文章之前，我觉得可以先看看下面这篇文章看printk引发的一点思考不管我们用的printk还是printf，它们的核心都是可变参数的函数，所以可以拼接很多参数传递给函数实体，然后...
自己写的一个简陋的C++栈模板
sunxysong的专栏
05-23 1408
说明:1.这个栈模板基于元素数组2.未对代码作仔细的测试#ifndef SUNXYSTACK_H#define SUNXYSTACK_H#define SMAX 200templateclass Stack{public: Stack(); Stack(int); ~Stack(); T& Top(); T& Pop(); bool Push(T&); bool isEmpty(); bool i
C++实现栈
TheClimb的池塘
08-23 380
之前在学习lua,看到网上一些博主用lua，实现一些基本的数据结构。突发其想，打算用C++好好重写下数据结构，夯实下自己的语言基础。 ------------------------------------------------------------------stack.h #pragma once #include #include #include using namespa
用C++实现栈的创建、输出、入栈、出栈
09-14
用C++实现栈的创建、输出、入栈、出栈 用C++实现栈的创建、输出、入栈、出栈 用C++实现栈的创建、输出、入栈、出栈
用C++线性栈实现简易计算器
12-18
主要使用的C++（含有部分C），使用的是线性栈，用的是栈的模板实现的计算器有良好的用户界面，输入表达式后都能计算。该计算器功能其实挺强大的，能够进行加减乘除、乘方、开方、求余等一系列计算，并且可以进行多次...
简易计算器 C++实现 基于栈 中缀转后缀
07-30
C++基于栈的建议计算器，支持+、-、*、/ 的基本运算。输入中缀表达式，转化成后缀表达式后再输出计算结果。自动检查括号不匹配、除数为0等异常。
C++ 用栈实现中缀表达式求值
04-01
简易数据结构
简易计算器C++与QT实现
07-15
在本项目中，"简易计算器C++与QT实现"是一个基于C++编程语言并结合了QT库构建的图形用户界面（GUI）应用程序。QT库是一个跨平台的应用开发框架，广泛用于创建美观且功能丰富的桌面应用。以下是这个项目的相关知识点...
纯C++简易结构库，包括栈、队列、字典、排序、树的操作
02-27
本知识点将围绕"纯C++简易结构库"这一主题，深入探讨栈、队列、字典（哈希表）和排序以及树的操作。 首先，栈（Stack）是一种后进先出（LIFO）的数据结构，常用于实现函数调用、表达式求值等场景。在C++中，可以...
c++栈的实现
baidu_41550746的博客
09-09 1558
最近在学习数据结构，栈在这里总结一下c++实现的栈几种方法：1.使用数组这是几种方法里面最为简单的方法，直接放代码： “` include using namespace std; template class arraystack { public: arraystack(); ~arraystack(); t peek(); t top(...
【C++】顺序栈
xing1584114471的博客
11-13 211
函数声明文件： #include <iostream> #include <assert.h> #define SIZE 10 #define TRUE 1 #define FALSE 0 using namespace std; class Stack { private: int *_data; int _size; int _top; //判满函数声明...
数据结构：C++实现栈的创建
T2114633320的博客
04-07 968
【代码】数据结构：C++实现栈的创建。
用c++实现栈
最新发布
m0_66452955的博客
03-19 388
主函数main():有测试数据。
C++ 类实现栈
soeben的博客
12-17 9725
#include &lt;iostream&gt; using namespace std; class Stack{ private: int* data_;//存放栈中的数据 int max_size_;//栈最大空间 int top_;//栈顶 //初始化栈 void initStack() { data_ = new int(max_...
C++ 类 实现栈
fasterry
11-27 5752
这个是类的实现“`includeusing namespace std; typedef int Item;typedef struct node{ Item data; struct node *pNext; } Node, *pNode; class STACK{ public: int size; pNode T
C++栈实现
Haku_yyf的博客
03-03 188
queue.h#include&lt;iostream&gt; struct MyStruct { int a[10]; int top; }; typedef struct MyStruct Struct; void init(Struct *p);//初始化栈 int isempty(Struct *p);//判断是否为空 int isfull(Struct *p);//判...
C++在类中实现栈功能
01-11 182
C++在类中实现栈功能。
用一个队列实现栈C语言
05-14
可以使用一个队列来实现一个栈，具体思路如下： 1. 定义一个队列结构体，包含一个数组和两个指针 front 和 rear，分别指向队列的头和尾。 2. 定义一个栈结构体，包含一个队列的指针和一个整数 top，表示栈顶元素的下标。 3. 入栈操作时，将元素插入队列的尾部，同时更新 top 的值。 4. 出栈操作时，将队列的 rear 指针指向的元素弹出，同时更新 top 的值。 5. 判断栈是否为空时，判断 top 的值是否为 -1。 下面是示例代码： ```c #include <stdio.h> #include <stdlib.h> #define MAXSIZE 100 // 定义队列结构体 typedef struct { int data[MAXSIZE]; int front; // 队首指针 int rear; // 队尾指针 } Queue; // 初始化队列 void initQueue(Queue *q) { q->front = q->rear = -1; } // 判断队列是否为空 int isEmpty(Queue *q) { return q->front == -1; } // 判断队列是否已满 int isFull(Queue *q) { return (q->rear + 1) % MAXSIZE == q->front; } // 入队操作 void enqueue(Queue *q, int x) { if (isFull(q)) { printf("Queue is full.\n"); return; } if (isEmpty(q)) { q->front = q->rear = 0; } else { q->rear = (q->rear + 1) % MAXSIZE; } q->data[q->rear] = x; } // 出队操作 int dequeue(Queue *q) { if (isEmpty(q)) { printf("Queue is empty.\n"); return -1; } int x = q->data[q->front]; if (q->front == q->rear) { q->front = q->rear = -1; } else { q->front = (q->front + 1) % MAXSIZE; } return x; } // 定义栈结构体 typedef struct { Queue *q; int top; // 栈顶指针 } Stack; // 初始化栈 void initStack(Stack *s) { s->q = (Queue *) malloc(sizeof(Queue)); initQueue(s->q); s->top = -1; } // 判断栈是否为空 int stackIsEmpty(Stack *s) { return s->top == -1; } // 入栈操作 void push(Stack *s, int x) { enqueue(s->q, x); s->top++; } // 出栈操作 int pop(Stack *s) { if (stackIsEmpty(s)) { printf("Stack is empty.\n"); return -1; } int i, x; // 将队列中的前 top 个元素出队再入队，实现栈的弹出操作 for (i = 0; i < s->top; i++) { x = dequeue(s->q); enqueue(s->q, x); } // 弹出栈顶元素 x = dequeue(s->q); // top 减 1 s->top--; return x; } int main() { Stack s; initStack(&s); push(&s, 1); push(&s, 2); push(&s, 3); printf("%d\n", pop(&s)); // 3 printf("%d\n", pop(&s)); // 2 printf("%d\n", pop(&s)); // 1 printf("%d\n", pop(&s)); // Stack is empty. return 0; } ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值