C++ 类模板实现栈和循环队列

栈头文件

cpp 复制代码
#ifndef MY_STACK_H
#define MY_STACK_H
template <typename T>
class My_Stack
{
private:
    T* m_stack;
    int m_length;
    int m_max;

public:
    My_Stack(int len);
    My_Stack(const My_Stack& obj);
    int length();
    int gettop();
    bool pop();
    bool push(int value);
    bool empty();
    bool full();
    bool show();
    bool clear();
    ~My_Stack();
};

#endif // MY_STACK_H

栈函数实现

cpp 复制代码
#include "my_Stack.h"
#include <iostream>

using namespace std;
template <typename T>
My_Stack<T>::My_Stack(int len):m_stack(nullptr),m_length(0),m_max(0)
{
    m_stack = new T[len];

    for(int i = 0; i < len; i++)
    {
        m_stack[i] = 0;
    }

    m_max = len;
}
template <typename T>
My_Stack<T>::My_Stack(const My_Stack& obj)
{
    m_max = obj.m_max;

    m_stack = new T[obj.m_max];

    for(int i = 0; i < obj.m_max; i++)
    {
        m_stack[i] = obj.m_stack[i];
    }
}
template <typename T>
int My_Stack<T>::length()
{
    return m_length;
}
template <typename T>
int My_Stack<T>::gettop()
{
    if(empty())
    {
        return -1;
    }

    int &top = m_stack[m_length-1];

    return top;
}
template <typename T>
bool My_Stack<T>::pop()
{
    bool ret = true;

    if(empty())
    {
        ret = false;
        cout << "栈为空" << endl;
        return ret;
    }

    m_length--;
    cout << "出栈成功" << endl;

    return ret;
}
template <typename T>
bool My_Stack<T>::push(int value)
{
    bool ret = true;

    if(full())
    {
        ret = false;
        cout << "栈已满" << endl;
        return ret;
    }

    m_stack[m_length] = value;
    m_length++;
    cout << "入栈成功" << endl;

    return ret;
}
template <typename T>
bool My_Stack<T>::empty()
{
    return m_length == 0;
}
template <typename T>
bool My_Stack<T>::full()
{
    return m_length == m_max;
}
template <typename T>
bool My_Stack<T>::show()
{
    bool ret = true;
    if(empty())
    {
        ret = false;
        cout << "栈为空" << endl;
        return ret;
    }

    for(int i = 0; i < m_length; i++)
    {
        cout << m_stack[i] << " ";
    }
    cout << endl;

    return ret;
}
template <typename T>
bool My_Stack<T>::clear()
{
    bool ret = true;

    if(empty())
    {
        ret = false;
        cout << "栈为空" << endl;
        return ret;
    }
    m_length = 0;

    cout << "栈已清空" << endl;

    return ret;
}
template <typename T>
My_Stack<T>::~My_Stack()
{
    delete[] m_stack;
}

循环队列头文件

cpp 复制代码
#ifndef MY_QUEUE_H
#define MY_QUEUE_H

template <typename T>
class My_Queue
{
private:
    T* m_queue;
    int front;
    int tail;
    int m_length;

public:
    My_Queue(int len);
    My_Queue(const My_Queue& obj);
    int length();
    bool pop();
    bool push(int value);
    bool empty();
    bool full();
    bool show();
    ~My_Queue();
};

#endif // MY_QUEUE_H

循环队列函数实现

cpp 复制代码
#include "my_Queue.h"
#include <iostream>

using namespace std;

template <typename T>
My_Queue<T>::My_Queue(int len):m_queue(nullptr),front(0),tail(0),m_length(0)
{
    m_queue = new T[len+1];

    for(int i = 0; i < len+1; i++)
    {
        m_queue[i] = 0;
    }

    m_length = len+1;
}
template <typename T>
My_Queue<T>::My_Queue(const My_Queue& obj)
{
    m_length = obj.m_length;

    m_queue = new T[obj.m_length];

    for(int i = 0; i < obj.m_length; i++)
    {
        m_queue[i] = obj.m_queue[i];
    }
}
template <typename T>
int My_Queue<T>::length()
{
    return (tail + m_length - front) % m_length;
}
template <typename T>
bool My_Queue<T>::pop()
{
    bool ret = true;

    if(empty())
    {
        cout << "队列为空" << endl;
        ret = false;
        return ret;
    }

    front = (front + 1) % m_length;
    cout << "出队成功" << endl;

    return ret;
}
template <typename T>
bool My_Queue<T>::push(int value)
{
    bool ret = true;

    if(full())
    {
        cout << "队列已满" << endl;
        ret = false;
        return ret;
    }

    m_queue[tail] = value;

    tail = (tail + 1) % m_length;
    cout << "入队成功" << endl;

    return ret;
}
template <typename T>
bool My_Queue<T>::empty()
{
    return front == tail;
}
template <typename T>
bool My_Queue<T>::full()
{
    return (tail + 1) % m_length == front;
}
template <typename T>
bool My_Queue<T>::show()
{
    bool ret = true;

    if( empty() )
    {
        ret = false;
        cout << "队列为空" << endl;
        return ret;
    }

    for(int i = front; i != tail; i = (i+1)%m_length)
    {
        cout << m_queue[i] << " ";
    }

    cout << endl;

    return ret;
}
template <typename T>
My_Queue<T>::~My_Queue()
{
    delete[] m_queue;
}
相关推荐
Michael_Good28 分钟前
【计算机网络】C/C++实现解析Wireshark离线数据包,附源码
c语言·c++·计算机网络
旺代1 小时前
C++设计模式(单例模式)
c++·单例模式·设计模式
材料苦逼不会梦到计算机白富美4 小时前
贪心算法-区间问题 C++
java·c++·贪心算法
羚羊角uou5 小时前
【C++】list模拟实现(详解)
开发语言·c++
Peter_chq6 小时前
【计算机网络】多路转接之select
linux·c语言·开发语言·网络·c++·后端·select
翀哥~9 小时前
python VS c++
开发语言·c++·python
HABuo10 小时前
【数据结构与算法】合并链表、链表分割、链表回文结构
c语言·开发语言·数据结构·c++·学习·算法·链表
努力学习编程的伍大侠11 小时前
C++中的移动语义
开发语言·c++
奇妙之二进制11 小时前
2025年春招修订版《C/C++笔面试系列》(1) C语言经典笔面试题(上)
c语言·c++·面试