c++多态 虚函数

【c++】自行封装一个栈的类，包含私有成员属性：栈的数组、记录栈顶的变量，要求成员函数完成：构造函数、析构函数、拷贝构造函数、入栈、出栈、清空栈、判空、判满、获取栈顶元素、求栈的大小，要求使用模板类

#include 

using namespace std;
template
class Stack
{
private:
    T *datatype;
    int size;                 //栈的大小
    int top;                 //记录栈顶元素的下标

public:
    //显性定义析构函数
    Stack(int Stacksize)
    {
        size=Stacksize;
        datatype=new int[size];
        top=-1;
    }
    //拷贝构造函数
    Stack(const Stack& other)
    {
        size=other.size;
        top=other.top;
        datatype=new int [size];
        //复制数据
        for(int i=0;i<=top;i++)
        {
            datatype[i]=other.datatype[i];
        }

    }
    //判空
    bool stack_empty()
    {
        return this->top==-1;

    }

    //判满
    bool stack_full()
    {
        return this->top==this->size-1;
    }


    //入栈
    int stack_push(T element)
    {
        if(!stack_full())
        {
            top++;
            datatype[top]=element;
            cout<<"入栈成功:"<=0;i--)
        {cout<size)
        {
            cout<<"获取栈顶元素失败"<stack(5);
    //入栈
    stack.stack_push(1);
    stack.stack_push(2);
    stack.stack_push(3);
    stack.stack_push(4);
    stack.stack_push(5);

    //show
    stack.stack_show();
    //求栈顶元素为
    stack.stack_top();
    //栈的大小
    cout<<"栈的大小为："<

 效果图：

 【c++】自行封装一个循环顺序队列的类，包含私有成员属性：存放队列的数组、队头位置、队尾位置，成员函数完成：构造函数、析构函数、拷贝构造函数、入队、出队、清空队列、判空、判满、求队列大小,要求实现成模板类

#include 

using namespace std;

template  //使用模板类

class Queue
{
    int size;
    T *datatype;   //存储队列的数组容器
    T front;                  //记录对头所在元素的下标
    T tail;    //记录最后一个元素的下一个位置的下标//队的大小

public:
    //显性定义无参析构函数
    Queue(int size)
    {
        datatype=new T[size];
        front=0;
        tail=0;
        this->size=size;
    }
    //拷贝构造函数
    Queue(const Queue &other)
    {
        size=other.size;
        front=other.front;
        front=other.front;
        datatype=new T [size];
        //复制数据
        for(int i=front;iq(5);
    //入队
    q.queue_push(0);
    q.queue_push(1);
    q.queue_push(2);
    q.queue_push(3);
    q.queue_push(4);

    //出队
    q.queue_pop();
    cout<<"队的大小"<

 效果图：

 【c++】定义一个英雄类，在英雄类下有两个子类，分别是：法师，坦克，要求用虚函数实现打野伤害值

#include 

using namespace std;
//定义一个英雄类
class Hero
{
protected:
    string name;    //姓名
    int Hp;               //血量
public:
    Hero(){cout<<"Hero::无参构造"<attack_jungle();
}

int main()
{
    Magic h1("妲己",300,50);
    Tank t1("亚瑟",500,200);
    fun(&h1);
    fun(&t1);
    cout<<"***************************"<

 效果图：

这段代码实现了一个英雄类（Hero）和两个子类（Magic和Tank），并测试了多态的实现。其中，英雄类包含姓名和血量属性，并提供了一个虚函数attack_jungle()，用于攻击野怪；子类Magic和Tank分别继承了英雄类，并重写了attack_jungle()函数。

在主函数中，首先创建了一个Magic对象h1和一个Tank对象t1，并通过fun()函数调用了它们的attack_jungle()函数。由于fun()函数的参数为Hero类型的指针，因此可以传入Magic和Tank对象的地址，实现了多态。

之后，通过引用方式创建了一个Hero对象ref，并调用了其attack_jungle()函数。由于ref引用的实际对象是Magic类型的对象h1，因此调用的是Magic类中重写的attack_jungle()函数。

最后，程序结束，输出析构函数的信息。

 多态实现条件

（1）继承：没有继承就没有多态

（2）虚函数：实现函数重写，保证父子类中使用同一个函数

（3）父类指针或引用指向子类对象，调用子类中重写的父类的虚函数

 虚函数：

（1） C++中可以将成员函数定义成虚函数，定义格式：在定义成员函数前加关键字virtual

（2）作用：以保证父类空间能够寻找到子类中重写的跟父类函数原型相同的函数