C++ 多态(二)

四、多态纯虚函数

纯虚函数是在C++中用来定义抽象类的一种特殊函数。纯虚函数没有具体的实现,只有函数声明,它的作用是为派生类提供一个接口,让派生类必须实现这个函数。如果一个类中包含了纯虚函数,那么这个类就是抽象类,不能被实例化。

如果一个类是有纯虚函数,那这个类就是抽象类。抽象类不能生成对象,需要子类继承。

另外纯虚函数不能被调用。

子类中virtual关键字可加可不加,子类继承默认虚函数。

五、多态析构函数

什么是虚析构函数?

父类指针在释放时,没有正确调用子类的析构函数,导致子类堆资源没有释放,内存泄露。

利用虚析构可以解决父类指针释放子类对象时不干净的问题

另外,系统提供的析构函数不是虚拟的,所以要用户自已提供虚析构函数。

纯虚析构函数的实现通常在类的定义外部提供,以确保派生类在实现自己的析构函数时能够调用基类的析构函数。(一般都采用虚析构函数,如果调用纯析构函数,需要类外声明,更繁琐)这样做是为了保证在销毁派生类对象时能正确地执行基类和派生类的清理操作 

六、多态案例

代码示例:

// 定义点类(二维,即包含x,y坐标) Point

// 定义一个图形类Figure:包含方法画图(onDraw)

// 定义一个三角形继承于图形类,

// 属性:三个点

// 方法:设置点,获取点等相关方法以及重写的画图方法

// 注:画图方法中要求打印出 画出的是一个什么图形和各个点坐标

// 定义一个圆形类,和三角形要求一致

// 定义一个画家类Painter

// void draw(Figure* f);

// 方法:画画:可以画出一个图形

// 测试画家画画,画一个三角形,一个圆形

#include <iostream>
#include <string>
using namespace std;

class Point{  
    public:
        int x;
        int y;
        Point():x{},y{}{}
        Point(int x,int y):x{x},y{y}{}
};
class Figure{
    public:
        virtual void onDraw() = 0;
        virtual ~Figure(){};
};
class Triangle:public Figure{
    private:
        Point p[3];
    public:
        Triangle(){}
        Triangle(Point p1,Point p2,Point p3)
        {
            this->p[0] = p1;
            this->p[1] = p2;
            this->p[2] = p3;
        }
        Point *getP()
        {
            return p;
        }
        void setP(Point p1,Point p2,Point p3)
        {
            this->p[0] = p1;
            this->p[1] = p2;
            this->p[2] = p3;
        }
        void onDraw()override
        {
            cout<<"画一个三角形"<<"三个点的坐标分别是:("<<p[0].x<<","<<p[0].y<<"),("<<p[1].x<<","<<p[1].y<<"),("<<p[2].x<<","<<p[2].y<<")"<<endl;
        }
};
class Circle:public Figure{
    private:
        int radius;
        Point center;
    public:
        Circle():radius{},center{}{}
        Circle(int radius,Point center):radius{radius},center{center}{}
        void setCenter(Point center)
        {
            this->center = center;
        }
        Point getCenter()const
        {
            return center;
        }
        void setRadius(int r)
        {
            this->radius = r;
        }
        int getRadius()const
        {
            return radius;
        }
        void onDraw()override
        {
            cout<<"画一个圆形"<<"圆心坐标:("<<center.x<<","<<center.y<<") 半径:"<<radius<<endl;
        }
};

class Painter{
    public:
    void draw(Figure *f)
    {
        f->onDraw();
    }
};

int main()
{
    Triangle t1(Point{1,2},Point{1,3},Point{2,2});
    Circle c1{2,Point{0,0}};
    Painter p;
    p.draw(&t1);
    p.draw(&c1);
    return 0;
}

运行结果:

画一个三角形三个点的坐标分别是:(1,2),(1,3),(2,2)
画一个圆形圆心坐标:(0,0) 半径:2
  • 20
    点赞
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C++中的多态(Polymorphism)是指在父类和子类之间的相互转换,以及在不同对象之间的相互转换。 C++中的多态性有两种:静态多态和动态多态。 1. 静态多态 静态多态是指在编译时就已经确定了函数的调用,也称为编译时多态C++中实现静态多态的方式主要有函数重载和运算符重载。 函数重载是指在同一作用域内定义多个同名函数,但它们的参数列表不同。编译器根据传递给函数的参数类型和数量来确定调用哪个函数。例如: ```c++ void print(int num) { std::cout << "This is an integer: " << num << std::endl; } void print(double num) { std::cout << "This is a double: " << num << std::endl; } int main() { int a = 10; double b = 3.14; print(a); // 调用第一个print函数 print(b); // 调用第个print函数 } ``` 运算符重载是指对C++中的运算符进行重新定义,使其能够用于自定义的数据类型。例如: ```c++ class Complex { public: Complex(double real, double imag) : m_real(real), m_imag(imag) {} Complex operator+(const Complex& other) const { return Complex(m_real + other.m_real, m_imag + other.m_imag); } private: double m_real; double m_imag; }; int main() { Complex a(1.0, 2.0); Complex b(3.0, 4.0); Complex c = a + b; // 调用Complex类中重载的+运算符 } ``` 2. 动态多态 动态多态是指在运行时根据对象的实际类型来确定调用哪个函数,也称为运行时多态C++中实现动态多态的方式主要有虚函数和纯虚函数。 虚函数是在父类中定义的可以被子类重写的函数,使用virtual关键字声明。当一个对象的指针或引用指向一个子类对象时,调用虚函数时会根据实际的对象类型来确定调用哪个函数。例如: ```c++ class Shape { public: virtual void draw() { std::cout << "Drawing a shape." << std::endl; } }; class Circle : public Shape { public: void draw() override { std::cout << "Drawing a circle." << std::endl; } }; int main() { Shape* shape_ptr = new Circle(); shape_ptr->draw(); // 调用Circle类中重写的draw函数 } ``` 纯虚函数是在父类中定义的没有实现的虚函数,使用纯虚函数声明(如virtual void func() = 0;)。父类中包含纯虚函数的类称为抽象类,抽象类不能被实例化,只能作为基类来派生子类。子类必须实现父类的纯虚函数才能实例化。例如: ```c++ class Shape { public: virtual void draw() = 0; }; class Circle : public Shape { public: void draw() override { std::cout << "Drawing a circle." << std::endl; } }; int main() { Shape* shape_ptr = new Circle(); shape_ptr->draw(); // 调用Circle类中重写的draw函数 } ```
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值