C++ Day6

目录

1> 将之前定义的栈类和队列类都实现成模板类

栈类

循环队列类

2>思维导图

---

1> 将之前定义的栈类和队列类都实现成模板类

栈类

#include <iostream>

using namespace std;

template <typename T>
class Sta
{
private:
    T arr[128];
    int len=-1;
public:
    // 显性定义无参构造函数
    Sta();

    //析构函数
    ~Sta();

    //拷贝构造函数
    Sta(const Sta &other);

    //判空
    bool Sta_empty();

    //判满
    bool Sta_full();

    //入栈
    void Sta_insert();

    //出栈
    void Sta_pop();

    //清空栈
    void Sta_outall();

    //获取栈顶元素
    T Sta_topdata();

    //求栈的大小
    int Sta_size();
};

// 显性定义无参构造函数
template <typename T>
Sta<T>::Sta()
{
    cout<<"Sta::无参构造"<<endl;
}

//析构函数
template <typename T>
Sta<T>::~Sta()
{
    cout<<"Sta::析构函数"<<endl;
}

//拷贝构造函数
template <typename T>
Sta<T>::Sta(const Sta &other)
{
    this->len=other.len;
    cout<<"Sta::拷贝构造函数"<<endl;
}

//判空
template <typename T>
bool Sta<T>::Sta_empty()
{
    if(-1==len)
    {
        return true;
    }
    return false;
}

//判满
template <typename T>
bool Sta<T>::Sta_full()
{
    if(127==len)
    {
        return true;
    }
    return false;
}

//入栈
template <typename T>
void Sta<T>::Sta_insert()
{
    if(Sta_full())
    {
        cout<<"栈满了，入栈失败"<<endl;
        return ;
    }
    T i;
    cout<<"请输入要入栈的数据：";
    cin>>i;
    arr[len+1]=i;
    len++;
    cout<<"入栈成功"<<endl;
    return ;
}

//出栈
template <typename T>
void Sta<T>::Sta_pop()
{
    if(Sta_empty())
    {
        cout<<"已经是空栈了，不能出栈了"<<endl;
        return ;
    }
    T i=0;
    i=arr[len];
    len--;
    cout<<i<<"出栈成功"<<endl;
    return ;
}

//清空栈
template <typename T>
void Sta<T>::Sta_outall()
{
    if(Sta_empty())
    {
        cout<<"已经是空栈了，不需要清空栈"<<endl;
        return ;
    }
   /* T temp=0;
    for(;len>=0;len--)
    {
        temp=arr[len];
        cout<<temp<<"出栈成功"<<endl;
    }*/
    len=-1;
    cout<<"清空栈完成"<<endl;
    return ;
}

//获取栈顶元素
template <typename T>
T Sta<T>::Sta_topdata()
{
    if(Sta_empty())
    {
        cout<<"空栈，获取个der"<<endl;
        return -1;
    }
    return arr[len];
}

//求栈的大小
template <typename T>
int Sta<T>::Sta_size()
{
    return len+1;
}


int main()
{
    Sta<double> six;
    six.Sta_insert();   //入栈
    six.Sta_insert();
    six.Sta_insert();
    six.Sta_insert();
    six.Sta_insert();
    six.Sta_pop();    //出栈

    cout<<"栈顶元素:"<<six.Sta_topdata()<<endl;

    cout<<"栈的大小为："<<six.Sta_size()<<endl;
    six.Sta_outall();   //清空栈

    return 0;
}

循环队列类

#include <iostream>

using namespace std;

template<typename T,typename D>
class Que
{
private:
    T arr[128];
    D front;
    D tail;
public:
    // 显性定义有参构造函数
    Que(D front,D tail);

    //析构函数
    ~Que();

    //拷贝构造函数
    Que(const Que &other);

    //判空
    bool Que_empty();

    //判满
    bool Que_full();

    //入队
    void Que_insert();

    //出队
    void Que_pop();

    //清空队
    void Que_outall();

    //求队的大小
    D Que_size();
};

// 显性定义无参构造函数
template<typename T,typename D>
Que<T,D>::Que(D front,D tail):front(front),tail(tail)
{
    cout<<"Que::有参构造"<<endl;
}

//析构函数
template<typename T,typename D>
Que<T,D>::~Que()
{
    cout<<"Que::析构函数"<<endl;
}

//拷贝构造函数
template<typename T,typename D>
Que<T,D>::Que(const Que &other)
{
    this->front=other.front;
    this->tail=other.tail;
    cout<<"Que::拷贝构造函数"<<endl;
}

//判空
template<typename T,typename D>
bool Que<T,D>::Que_empty()
{
    if(front==tail)
    {
        return true;
    }
    return false;
}

//判满
template<typename T,typename D>
bool Que<T,D>::Que_full()
{
    if((tail+1)%128==front)
    {
        return true;
    }
    return false;
}

//入队
template<typename T,typename D>
void Que<T,D>::Que_insert()
{
    if(Que_full())
    {
        cout<<"队满了，入队失败"<<endl;
        return ;
    }
    T i;
    cout<<"请输入要入队的数据：";
    cin>>i;
    arr[tail]=i;
    tail=(tail+1)%128;
    cout<<"入队成功"<<endl;
    return ;
}

//出队
template<typename T,typename D>
void Que<T,D>::Que_pop()
{
    if(Que_empty())
    {
        cout<<"已经是空队了，不能出队了"<<endl;
        return ;
    }
    T i=0;
    i=arr[front];
    front=(front+1)%128;
    cout<<i<<"出队成功"<<endl;
    return ;
}

//清空队
template<typename T,typename D>
void Que<T,D>::Que_outall()
{
    if(Que_empty())
    {
        cout<<"已经是空队了，不需要清空队"<<endl;
        return ;
    }
    /*
    cout<<"开始清空队列"<<endl;
    T temp=0;
    for(;front!=tail;front=(front+1)%128)
    {
        temp=arr[front];
        cout<<temp<<"出队成功"<<endl;
    }
    */
    front=tail=0;
    cout<<"清空队完成"<<endl;
    return ;
}


//求队的大小
template<typename T,typename D>
D Que<T,D>::Que_size()
{
    return (tail+128-front)%128;
}


int main()
{
    //有参 构造
    Que<double,int> six(0,0);

    six.Que_insert();    //入队
    six.Que_insert();
    six.Que_insert();
    six.Que_insert();
    six.Que_insert();
    six.Que_pop();      //出队

    cout<<"队的大小为："<<six.Que_size()<<endl;
    six.Que_outall();   //清空队

    return 0;
}

2>思维导图