c++多态 虚函数

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

#include <iostream>

using namespace std;
template<typename T>
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<<"入栈成功:"<<element<<endl;
            return 0;
        }
        cout<<"入栈失败"<<endl;
        return -1;
    }

    //遍历栈
    void stack_show()
    {
        cout<<"从栈顶到栈低的元素为：";
        for(int i=top;i>=0;i--)
        {cout<<datatype[i]<<"  ";

        }
        cout<<endl;
    }

    //出栈
    void stack_pop()
    {
        cout<<"出栈成功"<<datatype[top]<<endl;
        top--;
    }

    //获取栈顶元素
    void stack_top()
    {
        if(stack_empty()&&top>size)
        {
            cout<<"获取栈顶元素失败"<<endl;
        }
        cout<<"栈顶元素为："<<datatype[top]<<endl;
    }

    //求栈的大小
    int stack_size()
    {if(!stack_empty())
        {
        return top+1;
         }
        return -1;
    }
    //清空栈
    void stack_clear()
    {
        while(!stack_empty())
        {
            stack_pop();
        }
        if(stack_empty())
        {
            cout<<"sir,清空栈完毕"<<endl;
        }
    }
    ~Stack()
    {
        delete []datatype;
    }

};
int main()
{
    Stack <int>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<<"栈的大小为："<<stack.stack_size()<<endl;
    //弹栈
    stack.stack_pop();
    //清空栈
    stack.stack_clear();

    return 0;
}

 效果图：

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

#include <iostream>

using namespace std;

template<typename T>  //使用模板类

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;i<tail;i++)
        {
            datatype[front]=other.datatype[front];
        }
    }
    //判空
    bool queue_empty()
    {
        return front==tail;
    }

    //判满
    bool queue_full()
    {
        return (tail+1)%size==front;
    }

    //入队
    int queue_push(T element)
    {
        if(!queue_full())
        {
            datatype[tail]=element;
            tail=(tail+1)%size;
            cout<<element<<" : 入队成功"<<endl;
            return 0;

        }


        cout<<"入队失败"<<endl;
        return -1;
    }

    //出队
    int queue_pop()
    {
        if(queue_empty())
        {
            cout<<"出队失败"<<endl;
            return -1;
        }
        cout<<datatype[front]<<" : 出队成功"<<endl;
        front=(front+1)%size;
        return 0;
    }

    //求队的大小
    int queue_size()
    {
        return (tail-front+size)%size;
    }

    //清空队
    void queue_clear()
    {
        while(!queue_empty())
        {
        queue_pop();
        }
        if(queue_empty())
        {
            cout<<"sir,清空队成功"<<endl;
        }
    }
    ~Queue()
    {
        delete []datatype;
    }
};
//主函数
int main()
{
    Queue <int>q(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<<"队的大小"<<q.queue_size()<<endl;
    //清空队
    q.queue_clear();
    cout<<"队的大小"<<q.queue_size()<<endl;

    return 0;
}

 效果图：

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

#include <iostream>

using namespace std;
//定义一个英雄类
class Hero
{
protected:
    string name;    //姓名
    int Hp;               //血量
public:
    Hero(){cout<<"Hero::无参构造"<<endl;}
    Hero(string n,int h):name(n),Hp(h){cout<<"Hero::有参构造"<<endl;}
    ~Hero(){cout<<"Hero::析构函数"<<endl;}

    //父类中提供虚函数
    virtual void attack_jungle()
    {
        cout<<name<<"攻击了野怪,血量减100"<<endl;
    }
};

//定义法师类，继承自英雄类
class Magic:public Hero
{
private :
    int ap;         //基础法强
public:
    Magic(){cout<<"Magic::无参构造"<<endl;}
    Magic(string n,int h,int a):Hero(n,h),ap(a){cout<<"Magic::有参构造"<<endl;}
    ~Magic (){cout<<"Magic::析构函数"<<endl;}

    //子类中重写父类虚函数
    virtual void attack_jungle()
    {
        cout<<name<<"攻击了野怪,血量减66"<<endl;
    }

};
//定义刺客类，继承自英雄类
class Tank:public Hero
{
private :
    int dikang;         //基础抗性
public:
    Tank(){cout<<"无参构造"<<endl;}
    Tank(string n,int h,int a):Hero(n,h),dikang(a){cout<<"有参构造"<<endl;}
    ~Tank(){cout<<"Tank::析构函数"<<endl;}

    //子类中重写父类虚函数
    virtual void attack_jungle()
    {
        cout<<name<<"攻击了野怪,血量减88"<<endl;
    }

};

//定义全局函数，用于打野
void fun(Hero *h)
{
    h->attack_jungle();
}

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

    Hero &ref=h1;
    ref.attack_jungle();
    cout<<"***************************"<<endl;
    return 0;
}

 效果图：

这段代码实现了一个英雄类（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）作用：以保证父类空间能够寻找到子类中重写的跟父类函数原型相同的函数