父域 Cookie实现sso单点登录

栈模板类

#include <iostream>
#define Max 100
using namespace std;
template <typename S>
//链式栈
class Stack
{
private:
    S *data;             //存放数据的指针
    int top;              //栈顶元素下标
public:
    Stack():top(-1),data(new S[Max])
    {
        cout<<"无参构造"<<endl;
    }

    ~Stack()
    {
        delete []data;
        cout<<"析构函数"<<endl;
    }
    //入栈
    S stack_pop(S e, S *data);
    //遍历栈
    void stack_show(S *data);
    //出栈
    S stack_push(S *data);
    //判空
    int stack_empty(S *data);
    //判满
    S stack_full(S *data);
    //获取栈顶元素
    S &Stack_get_top(S *data);
    //求栈的大小
    int stack_size(S *data);
};
template <typename S>
//入栈
S Stack<S>::stack_pop(S e,S *data)
{
    if(data == NULL||stack_full(data))
    {
        cout<<"入栈失败"<<endl;
        return -1;
    }
    //先加后压
    top ++;
    data[top] = e;
    return 0;

}
template <typename S>
//遍历栈
void Stack<S>::stack_show(S *data)
{
    if(data == NULL||stack_empty(data))
    {
        cout<<"遍历失败"<<endl;
        return ;
    }
    for(int i=top;i>=0;i--)
    {
        cout<<data[i]<<" ";
    }
    cout<<endl;
    return ;
}
//出栈
template <typename S>
S  Stack<S>::stack_push(S *data)
{
    if(data == NULL||stack_empty(data))
    {
        cout<<"出栈失败"<<endl;
        return -1;
    }
    //先弹后减
    S e = data[top];
    top --;
    return 0;
}
//判空
template <typename S>
int Stack<S>::stack_empty(S *data)
{
    if(data == NULL)
    {
        cout<<"不合法"<<endl;
    }
    return top == -1;
}
//判满
template <typename S>
S Stack<S>::stack_full(S *data)
{
    if(data ==NULL)
    {
        cout<<"不合法"<<endl;
        return -1;
    }
    return top == Max-1;
}
//获取栈顶元素
template <typename S>
S &Stack<S>::Stack_get_top(S *data)
{
    if(data == NULL||stack_empty(data))
    {
        cout<<"获取栈顶元素失败"<<endl;
    }
    return data[top];

}
//求栈的大小
template <typename S>
int Stack<S>::stack_size(S*data)
{
    if(data == NULL||stack_empty(data))
    {
        cout<<"获取栈顶元素失败"<<endl;
        return -1;
    }
    return top+1;
}
int main()
{
    Stack<double>s1;
    double a[Max];
    s1.stack_pop(3.0,a);
    s1.stack_pop(3.1,a);
    s1.stack_pop(3.2,a);
    s1.stack_pop(3.3,a);
    s1.stack_show(a);
    int len = s1.stack_size(a);
    cout<<"栈的大小是："<<len<<endl;
    cout<<"栈顶元素是:"<<s1.Stack_get_top(a)<<endl;
    Stack<int>s2;
    int b[Max];
    s2.stack_pop(10,b);
    s2.stack_pop(20,b);
    s2.stack_pop(30,b);
    s2.stack_pop(40,b);
    s2.stack_pop(50,b);
    s2.stack_pop(60,b);
    s2.stack_show(b);
    s2.stack_push(b);
    s2.stack_push(b);
    s2.stack_push(b);
    s2.stack_push(b);
    s2.stack_show(b);
    int len1 = s2.stack_size(b);
    cout<<"栈的大小是:"<<len1<<endl;
    cout<<"栈顶元素是:"<<s2.Stack_get_top(b)<<endl;

    return 0;
}

队列模板类

#include <iostream>
#define Max 40
using namespace std;
template <typename Q>
class Queue
{
private:
    Q *data; //存放队列的数组
    int head;   //队头下标
    int tail;   //队尾下标
public:
    Queue():data(new Q[Max]),head(tail=0),tail(head=0)
    {}
    ~Queue()
    {
        delete [] data;
    }
    //判空
    int  queue_empty(Q *data);
    //判满
    int  queue_full(Q *data);
    //入列
    Q queue_pop(Q e,Q *data);
    //遍历
    void queue_show(Q *data);
    //出列
    Q queue_push(Q *data);
    //求队列大小
    int queue_size(Q *data);

};

//判空
template <typename Q>
int Queue<Q>::queue_empty(Q *data)
{
    if(nullptr == data)
    {
           cout<<"不合法!"<<endl;
           return -1;
    }
    return head == tail;
}
//判满
template <typename Q>
int Queue<Q>::queue_full(Q *data)
{
    if(nullptr == data)
     {
         cout<<"不合法!"<<endl;
         return -1;
     }
   return (tail+1)%20 == head;

}
//入列
template <typename Q>
Q Queue<Q>::queue_pop(Q e,Q *data)
{
    if(NULL==data||queue_full(data))
    {
        cout<<"入队失败"<<endl;
        return -1;
    }
    data[tail] = e;
    tail=(tail+1)%Max;
    return 0;
}
//遍历
template <typename Q>
void Queue<Q>::queue_show(Q *data)
{
    if(NULL==data||queue_empty(data))
    {
        cout<<"遍历失败"<<endl;
        return ;
    }
    for(int i=head;i!=tail;i=(i+1)%Max)
    {
        cout<<data[i]<<" ";
    }
    cout<<endl;
    return ;

}
//出列
template <typename Q>
Q Queue<Q>::queue_push(Q *data)
{
    if(NULL==data||queue_empty(data))
    {
        cout<<"出列失败"<<endl;
        return -1 ;
    }
    Q e =data[head];
    head=(head+1)%Max;
    return 0;
}
//求队列大小
template <typename Q>
int Queue<Q>::queue_size(Q *data)
{
    if(NULL==data||queue_empty(data))
    {
        cout<<"出列失败"<<endl;
        return -1 ;
    }
    return (tail-head+Max)%Max;
}
int main()
{
    Queue<int>q1;
    int a[Max];
    q1.queue_pop(1,a);
    q1.queue_pop(2,a);
    q1.queue_pop(3,a);
    q1.queue_show(a);
    return 0;
}