C++day6

模板类实现封装栈

#include 
#define MAX 128
using namespace std;
 
template <typename T>
class Stack
{
private:
    T *p = new T[MAX];//存放数据的数组
    int top;//记录下标位置
 
public:
    //构造函数
    Stack()
    {
        top = -1;
        cout<<"无参构造函数"<
    }
    //析构函数
    ~Stack()
    {
        cout<<"Stack::析构函数"<
    }
    //拷贝构造函数
    Stack(const Stack &other):p(new T[MAX]),top(other.top)
    {
        cout<<"拷贝构造函数"<
    }
    //入栈
    bool stack_push(T e);
    //出栈
    bool stack_pop();
    //清空栈
    void stack_free();
    //判空
    int stack_empty();
    //判满
    int stack_full();
    //获取栈顶元素
    T stack_top();
    //栈的大小
    int stack_size();
};
 
//栈的大小
template <typename T>
int Stack::stack_size()
{
    cout<<"栈的大小为 "<1<
    return top+1;
}
 
//获取栈顶元素
template <typename T>
T Stack::stack_top()
{
    if(stack_empty())
    {
        cout<<"获取失败"<
        return -1;
    }
    cout<<"栈顶元素为 "<
    return p[top];
}
 
//判满
template <typename T>
int Stack::stack_full()
{
    return top == MAX-1;
 
}
//判空
template <typename T>
int Stack::stack_empty()
{
    return top == -1;
}
//清空栈
template <typename T>
void Stack::stack_free()
{
    while(top != -1)
    {
        stack_pop();
    }
    cout<<"清空成功"<
}
 
 
//出栈
template <typename T>
bool Stack::stack_pop()
{
    if(stack_empty())
    {
        return false;
    }
    T e = p[top];
 
    top--;
    cout<" 出栈成功"<
 
    return  true;
}
 
 
//入栈
template <typename T>
bool Stack::stack_push(T e)
{
    if(stack_full())
    {
        cout<<"入栈失败"<
        return false;
    }
    top++;
    p[top] = e;
    cout<" 入栈成功"<
 
    return true;
}
int main()
{
    Stack<int> s1;
    s1.stack_push(4);
    Stack<int> s3 = s1;
    s3.stack_pop();
    s3.stack_size();
    s1.stack_pop();
    Stack s2;
    s2.stack_push("hello");
    s2.stack_pop();
 
    return 0;
}

模板类封装队列

#include 
#define MAX 128
using namespace std;
template<typename T>
class Queue_q
{
private:
    T *p=new T[MAX];//队列的数组
    int tail;//记录队尾元素
    int head;//记录对头元素
public:
    //构造函数
    Queue_q(int t=0)
    {
        head=t;
        tail=t;
        cout<<"无参构造函数"<
    }
    //析构函数
    ~Queue_q()
    {
        cout<<"Stack::析构函数"<
    }
    //拷贝构造函数
    Queue_q(const Queue_q &other):p(new T[MAX]),tail(other.tail),head(other.head)
    {
        cout<<"拷贝构造函数"<
    }
    //入队
    int queue_push(T e);
    //出队
    int queue_pop();
    //清空队列
    int queue_delete();
    //判空
    bool queue_empty();
    //判满
    bool queue_full();
    //队列的大小
    void queue_getsize();
    void show(int i)
    {
         cout<" ";
    }
};
//入队
template<typename T>
int Queue_q::queue_push(T e)
{
    if(queue_full())
    {
        cout<<"入队失败"<
        return -1;
    }
    p[tail]=e;
    tail=(tail+1)%MAX;
    cout<<"入队成功"<
    return 0;
}
//出队
template<typename T>
int Queue_q::queue_pop()
{
    if(queue_empty())
    {
        cout<<"出队失败"<
        return -1;
    }
    T e=p[head];
    head=(head+1)%MAX;
    cout<" 出队成功"<
    return 0;
}
//清空队列
template<typename T>
int Queue_q::queue_delete()
{
    while(head!=tail)
    {
        queue_pop();
    }
    delete [] p;
    p=nullptr;
    cout<<"清空队列成功"<
    return 0;
}
//判空
template<typename T>
bool Queue_q::queue_empty()
{
    if(head==tail)
    {
        cout<<"队列空"<
        return 1;
    }
    return 0;
}
//判满
template<typename T>
bool Queue_q::queue_full()
{
    if((tail+1)==0)
    {
        cout<<"队列满了"<
        return 1;
    }
    return 0;
}
//队列的大小
template<typename T>
void Queue_q::queue_getsize()
{
    int size;
    size=(tail-head+MAX)%MAX;
    cout<<"队的大小为："<
}
int main()
{
    //实例一个double类型的队列
    Queue_q<double> q1;
    double e;
    int s;
    q1.queue_empty();
    cout<<"请输入要入队的个数：";
    cin>>s;
    for(int i=0;i
    {
        cout<<"请输入要入队的元素：";
        cin>>e;
        q1.queue_push(e);
    }
     q1.queue_getsize();
    for(int i=0;i
    {
        q1.show(i);
    }
    cout<
    q1.queue_delete();
    //实例一个string类型的队列
    Queue_q q2;
    string e1;
    int s2;
    q2.queue_empty();
    cout<<"请输入要入队的个数：";
    cin>>s2;
    for(int j=0;j
    {
        cout<<"请输入要入队的元素：";
        cin>>e1;
        q2.queue_push(e1);
    }
     q2.queue_getsize();
    for(int j=0;j
    {
        q2.show(j);
    }
    cout<
    q2.queue_delete();
    Queue_q q3 = q2;
    return 0;
 
}