C++基础：多态，虚函数的用法

最新推荐文章于 2024-09-01 23:00:30 发布
最新推荐文章于 2024-09-01 23:00:30 发布
阅读量261 收藏 1
点赞数
分类专栏： C++ 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_39398433/article/details/117995261
版权

文章目录

1. 重写（覆盖）：虚函数

在很多C++书籍上没有覆盖(overrride)这种称谓，而是直接称为多态(polymorphism)

#include <iostream>
using namespace std;

class Base{
public:
        Base(){
                cout << __func__ << endl;
        }
        ~Base(){
                cout << __func__ << endl;
        }
        virtual void Test(){     // 虚函数
                cout << "Base::Test" << endl;
        }
};

class Derive:public Base{
public:
        Derive(){
                cout << __func__ << endl;
        }
        ~Derive(){
                cout << __func__ << endl;
        }
        void Test(){
                cout << "Derive::Test" << endl;
        }
};

int main(){
        Derive d;
        Base& b = d;
        b.Test();       // 对象类型决定调用函数
}

结果为：

Base
Derive
Derive::Test
~Derive
~Base

多态中虚函数的作用：

  1. 对象类型决定调用顺序
  2. 如果调用的函数是虚函数（加了virtual），查看指针/引用指向对象类型中，是否有完全相同的函数，如果有，调用指向对象中的函数，否则调用父类函数

重写的应用：直角三角形计算面积方法可以不用海伦公式，而是用两直角边的乘积除以2

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

// 三角形
class Triangle{
protected:
        int a,b,c;
public:
        Triangle():a(0),b(0),c(0){}
        Triangle(int a,int b,int c):a(a),b(b),c(c){}
        int GetLength() const{
                return a+b+c;
        }
        virtual float GetArea() const{       // 虚函数，在前面加virtual
                float q = GetLength()/2.0;
                return sqrt(q*(q-a)*(q-b)*(q-c));  //海伦公式
        }
};

// 等腰三角形
class IsoscelesTriangle:public virtual Triangle{      /* 虚继承 */
public:
        IsoscelesTriangle(int side,int iso){
                a = side;
                b = iso;
                c = iso;
        }
};

// 等边三角形
class EqualTriangle:public Triangle{
public:
        EqualTriangle(int a):Triangle(a,a,a){}
};

// 直角三角形
class RightAngledTriangle:public virtual Triangle{    /* 虚继承 */
public:
        RightAngledTriangle(int a,int b,int c):Triangle(a,b,c){}
        float GetArea() const{
                cout << "RightAngledTriangle::GetArea" << endl;     // 表明调用到的是这个函数
                return a*b/2.0;
        }
};

// 等腰直角三角形
class IsoselesRightAngledTriangle:public IsoscelesTriangle,public RightAngledTriangle{
public:
        IsoselesRightAngledTriangle(int side,int iso):IsoscelesTriangle(side,iso),RightAngledTriangle(side,iso,iso){}
};

void Print(Triangle t){
        cout << t.GetLength() << " " << t.GetArea() << endl;
}

void Print2(Triangle& t){
        cout << t.GetLength() << " " << t.GetArea() << endl;
}

void Print3(Triangle* t){
        cout << t->GetLength() << " " << t->GetArea() << endl;
}

int main(){
        Triangle t(3,4,5);
        Print2(t);

        RightAngledTriangle r(3,4,5);
        Print2(r);    // Triangle& t = r;

        Triangle* arr[] = {
                new Triangle(2,3,4),
                new IsoscelesTriangle(3,5),
                new EqualTriangle(5),
                new IsoselesRightAngledTriangle(sqrt(2),1)       // 调用的是直角三角形
        };

        for(int i=0;i<4;++i){
                cout << arr[i]->GetLength() << "\t" << arr[i]->GetArea() << endl;
        }
}

结果为：

12 6
12 RightAngledTriangle::GetArea
6
9	2.90474
13	7.15454
15	10.8253
3	RightAngledTriangle::GetArea
0.5

对于上述的这个例子：

  1. 如果是普通三角形，直接调用自己的成员函数
  2. 如果是直角三角形，对象类型决定调用顺序，所以本应该调用父类下的面积函数，但由于父类下的面积函数是虚函数，所以查看指针/引用指向对象类型中，有完全相同的函数，调用指向对象中的函数
  3. 如果是特殊的非直角三角形，对象类型决定调用顺序，所以本应该调用父类下的面积函数，但由于父类下的面积函数是虚函数，所以查看指针/引用指向对象类型中，没有完全相同的函数，依然调用父类函数

覆盖成立的三个条件：

  1. 继承
  2. 子类覆盖(重写)父类虚函数
  3. 父类指针/引用指向子类

虚函数定义规则：

  1. 如果虚函数在基类与派生类中出现，仅仅是名字相同，而形式参数不同，或者是返回类型不同，有无const，那么即使加上了virtual关键字，也是不会覆盖。所以需要两个函数完全相同。
  2. 只有类的成员函数才能说明为虚函数，因为虚函数仅适合用与有继承关系的类对象，所以普通函数不能说明为虚函数。
  3. 静态成员函数不能是虚函数，因为静态成员函数的特点是不受限制于某个对象。
  4. 内联(inline)函数不能是虚函数，因为内联函数不能在运行中动态确定位置。即使虚函数在类的内部定义，但是在编译的时候系统仍然将它看做是非内联的。
  5. 构造函数不能是虚函数，因为构造的时候，对象还是一片未定型的空间，只有构造完成后，对象才是具体类的实例。
  6. 析构函数可以是虚函数，而且通常声明为虚函数。

2. 虚析构函数

#include <iostream>
using namespace std;

class Base{
public:
        Base(){
                cout << __func__ << endl;
        }
        virtual ~Base(){     // 虚析构函数，前面加virtual,先去调用子类的析构函数再调用父类的析构函数
                cout << __func__ << endl;
        }
        virtual void Test(){
                cout << "Base::Test" << endl;
        }
};

class Derive:public Base{
public:
        Derive(){      // Derive():Base(){}
                cout << __func__ << endl;
        }
        ~Derive(){
                cout << __func__ << endl;
        }
        void Test(){         // 同名隐藏
                cout << "Derive::Test" << endl;
        }
};

int main(){
        // Derive d;
        // Base* p = &d;
        Base* p = new Derive;
        p->Test();
        delete p;     // 因为p是base类型的，所以只调用了父类的析构函数，不调用子类的析构函数
}

结果为：

Base
Derive
Derive::Test
~Derive
~Base

定义虚析构函数表示：
表示先去调用子类的析构函数再调用父类的析构函数
如果类中定义了虚函数，一定要定义虚析构函数
避免内存泄漏的发生

3. 虚函数的本质

#include <iostream>
using namespace std;

class Base{
        // void* vtpr; 虚函数表指针，虚函数表是一个virtual函数指针数组
        int n;
public:
        Base(){
                cout << __func__ << endl;
        }
        ~Base(){
                cout << __func__ << endl;
        }
        virtual void Test(){
                cout << "Base::Test" << endl;
        }
        void Test(int n){
                cout << "Base::Test(" << n << ")" << endl;
        }
};

int main(){
        Base b;
        cout << sizeof(b) << endl;
}

结果为：

Base
16
~Base

在这里插入图片描述

4. 纯虚函数

override 用来检查子类的这个函数有没有对应父类中可以覆盖的函数
如果找不到或者写错，就会报错

final 写在父类成员函数后，终止后续继承的函数进行重写
如果对应子类中有重写的成员函数，就会报错

#include <iostream>
using namespace std;

class Base{
public:
        virtual void Test(){
                cout << "Base::Test" << endl;
        }
};

class Derive:public Base{
public:
        void Test() override {
                cout << "Derive::Test" << endl;
        }
};

int main(){
        Base b;
        b.Test();

        Derive d;
        d.Test();

        // 多态/覆盖
        Base& f = d;
        f.Test();
}

结果为：

Base::Test
Derive::Test
Derive::Test

纯虚函数：

#include <iostream>
using namespace std;

class Base{     // 抽象类
public:
        virtual void Test() = 0;    // 纯虚函数
        /* 是不实现的
        {
                cout << "Base::Test" << endl;
        }
        */
};

class Derive:public Base{
public:
        void Test() override {
                cout << "Derive::Test" << endl;
        }
};

int main(){
        // Base b;    抽象类不能定义对象
        // b.Test();

        Derive d;
        // 多态/覆盖
        Base& f = d;      // 可以定义指针和引用
        f.Test();
}

结果为：

Derive::Test

纯虚函数的应用：
定义抽象类，可以计算圆形和三角形的周长和面积，计算公式不同可因情况而分析，更加灵活

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

class Shape{     // 抽象类
public:
        virtual int GetLength() const = 0;
        virtual float GetArea() const = 0;
};

// 圆形
class Circle:public Shape{
        int r;
public:
        Circle(int r):r(r){}
        int GetLength() const{
                return 2*M_PI*r;
        }
        float GetArea() const{
                return  M_PI*r*r;
        }
};

// 三角形
class Triangle:public Shape{
protected:
        int a,b,c;
public:
        Triangle():a(0),b(0),c(0){}
        Triangle(int a,int b,int c):a(a),b(b),c(c){}
        int GetLength() const{
                return a+b+c;
        }
        float GetArea() const /* final */{
                float q = GetLength()/2.0;
                return sqrt(q*(q-a)*(q-b)*(q-c));
        }
};

// 等腰三角形
class IsoscelesTriangle:public virtual Triangle{      /* 虚继承 */
public:
        IsoscelesTriangle(int side,int iso){
                a = side;
                b = iso;
                c = iso;
        }
};

// 等边三角形
class EqualTriangle:public Triangle{
public:
        EqualTriangle(int a):Triangle(a,a,a){}
};

// 直角三角形
class RightAngledTriangle:public virtual Triangle{    /* 虚继承 */
public:
        RightAngledTriangle(int a,int b,int c):Triangle(a,b,c){}
};

// 等腰直角三角形
class IsoselesRightAngledTriangle:public IsoscelesTriangle,public RightAngledTriangle{
public:
        IsoselesRightAngledTriangle(int side,int iso):IsoscelesTriangle(side,iso),RightAngledTriangle(side,iso,iso){}
};

int main(){
        Shape* arr[] = {
                new Triangle(2,3,4),
                new IsoscelesTriangle(3,5),
                new EqualTriangle(5),
                new IsoselesRightAngledTriangle(sqrt(2),1),
                new Circle(1)        // 求圆形
        };

        for(int i=0;i<5;++i){
                cout << arr[i]->GetLength() << "\t" << arr[i]->GetArea() << endl;
        }

结果为：

9	2.90474
13	7.15454
15	10.8253
3	0.433013
6	3.14159

重载和覆盖的区别：

重载覆盖
重载要求函数名相同，但是参数列表必须不同，返回值可以相同也可以不同。覆盖要求函数名、参数列表、返回值必须相同。
在类中重载是同一个类中不同成员函数之间的关系。在类中覆盖则是子类和基类之间不同成员函数之间的关系。
重载函数的调用是根据参数列表决定。覆盖函数的调用是根据对象类型决定。
重载函数是在编译时确定调用一个函数。覆盖函数是在执行时确定调用个函数。
干货——C++虚函数的使用方法
qq_45993891的博客
03-08 472
虚函数的作用 虚函数的使用方法 在什么情况下应该声明虚函数 使用虚函数时，有两点要注意: 只有类的成员函数才能被声明虚函数，即虚函数只用于类的继承层次结构中 一个成员函数被声明为虚函数后，在同一类族中的类就不能再定义一个该虚函数同名、同类型和同参数同名非虚函数。 使用虚函数，系统要有一定的额外空间开销。 当一个类带有虚函数时，编译系统会为该类构造一个虚函数表(virtual function ta...
坚持学习100天：多态（函数重载、虚函数和多态）
m0_55732114的博客
04-29 282
前言 Hello,我是修齊。 学习C++的第一百零一十天,将近五一假期了，不浪漫亦是罪名，男生今年不能再挨批斗了，放假就得好好陪陪身边的人浪漫浪漫，生活，加油，学习加油。 在这里记录一些学习的东西和学习的心情,内容主要是一些自己学习整理的小笔记。 一、多态 1.一个接口,多种实现:同一种事务表现出来的多种形态 2.面向对象的多态性可分为四类:重载多态、强制多态、包含多态、参数多态 3.专用多态：重载多态和强制多态；通用多态：包含多态和参数多态 4.包含多态：定义于不同类中的同名成员函数的多态行为，主要通过虚
c++虚函数的使用方法
热门推荐
奋斗在路上
05-08 3万+
虚函数的使用方法： （1）在基类用virtual声明成员函数为虚函数。这样就可以在派生类中重新定义此函数，为它赋予新的功能，并能方便被调用。 在类外定义虚函数时，不必在定义virtual （2）在派生类中重新定义此函数，要求函数名，函数类型，函数参数个数和类型全部与基类的虚函数相同，并根据派 生类的需要重新定义函数体。 c++规定，当一个成员函数被声明为虚函数后，其派生类的
多态（虚函数、纯虚函数、虚函数表）
最新发布
aurorahhmllm的博客
09-01 690
随后，当执行到派生类的构造函数时，如果派生类有自己的虚函数表（通常是因为派生类重写了基类的虚函数或添加了新的虚函数），则对象的 vptr 会被更新为指向派生类的虚函数表。不同对象vptr共享同一片内存，一个vptr变成null会影响其他的 和深拷贝，重新分配新内存，不会影响），但是指向的地址是一样的（都是指向类的虚函数表，也就是会共享相同的虚函数表指针内容）建议进行深拷贝。，存储在对象中的指针vptr，指向该对象所属类的虚函数表，就是指向虚函数表的指针。虚函数表是虚函数地址的数组，指向代码区中的地方。
C++虚函数的用法
qq_41979469的博客
05-26 563
从类模板实例化的每个模板类有自己的类模板数据成员，该模板类的所有对象共享一个static数据成员 和非模板类的static数据成员一样，模板类的static数据成员也应该在文件范围定义和初始化 每个模板类有自己的类模板的static数据成员副本 class A { public: virtual ~A(){ cout << "A::~A() is called....
c++虚函数用法
hotdog156351的专栏
03-07 657
 C++中的虚函数的作用主要是实现了多态的机制。关于多态，简而言之就是用父类型别的指针指向其子类的实例，然后通过父类的指针调用实际子类的成员函数。这种技术可以让父类的指针有“多种形态”，这是一种泛型技术。所谓泛型技术，说白了就是试图使用不变的代码来实现可变的算法。比如：模板技术，RTTI技术，虚函数技术，要么是试图做到在编译时决议，要么试图做到运行时决议。 关于虚函数的使用方法，我在这
C++中虚函数的使用方法：
qq_26008971的博客
03-27 336
虚函数的使用方法：（1）在基类用virtual声明成员函数为虚函数。这样就可以在派生类中重新定义此函数，为它赋予新的功能，并能方便被调用。在类外定义虚函数时，不必在定义virtual （2）在派生类中重新定义此函数，要求函数名，函数类型，函数参数个数和类型全部与基类的虚函数相同，并根据派生类的需要重新定义函数体。c++规定，当一个成员函数被声明为虚函数后，其派生类的同名函数都自动成为虚函数。因此在...
C++面向对象：多态与虚函数解析
"C++课程关于类、继承、派生、多态与虚函数的概述" 在C++编程中，类是构建对象的基础，它定义了一组属性和操作，即数据成员和成员函数。继承是面向对象编程的一个核心概念，允许我们创建新的类，这些新类（派生类）...
Linux C++：多态（虚函数和纯虚函数）
qq_39734379的博客
05-13 472
多态：按字面的意思就是多种形态。当类之间存在层次结构，并且类之间是通过继承关联时，就会用到多态。C++ 多态意味着调用成员函数时，会根据调用函数的对象的类型来执行不同的函数。 定义：在某基类中声明为 virtual 并在一个或多个派生类中被重新定义的成员函数，用法格式为：virtual 函数返回类型 函数名（参数表） {函数体}；实现多态性，通过指向派生类的基类指针或引用，访问派...
C++虚函数多态和纯虚函数多态的经典示例源码
02-25
虚函数是C++中实现多态的基础。当在一个基类中声明一个虚函数时，这个函数可以在派生类中被重写，从而允许通过基类指针或引用调用派生类的版本。这样，即使不知道对象的确切类型，也可以执行适当的成员函数。例如： ...
C++虚函数和多态
wo_ai_luo_的博客
11-18 659
由前面的内容，我们可以总结出多态的相关内容：使用多态时，程序不必为每一个派生类都编写函数调用，派生类可以只关注本类中对应函数的实现功能，做到基类函数的同一接口的不同实现方式，大大提高了程序的可复用性；同时，基类也可以调用派生类的成员，即向后兼容，提高了程序的可扩充性和可维护性。后一点内容我们在以后的文章中会介绍。总之，多态是面向过程编程和面向对象编程的显著差异之一。灵活使用多态对于编写健壮、可扩充、可复用的程序至关重要。
c++的虚函数使用
tutu1583的专栏
10-28 263
虚函数的使用 之前的代码如下： #include using namespace std; class base //定义基类base { int x, y; //定义基类私有成员 public: base(int xx = 0, int yy = 0) //定义构造函数 { x = xx; y = yy;
【C++语法】虚函数的使用
大草的博客
01-28 2137
以虚函数为出发点，简单修改了书上的代码，将继承关系下的动态绑定使用示例的方式展示出来。
虚函数的使用方法
sinat_19868271的博客
06-05 5455
( 1 ）在基类用 virtual 关键字声明成员函数为虚函数。 这样就可以在派生类中重新定义此函数，为它赋予新的功能，并能方便地被调用 。 在类 外定义虚函数时，不必再加 virtual 关键字。( 2 ）在派生类中重新定义此函数，要求函数名 、 函数类型 、 函数参数个数和类型全部与 基类的虚函数相同，并根据派生类的需要重新定义函数体。 C＋＋规定，当一个成员函数被声 明为虚函数后，其派生类中...
虚函数用法
todhacker111的专栏
01-10 242
<br />#include <iostream> using namespace std; class B { public: virtual void f(int i) {cout<<"B::f"<<endl;} }; class D:public B { public: int f(char c) {cout<<"D::f..."<<c<<endl;} }; void main() {D d; B *pB=&d,&rB=d,b; pB->f('1');
虚函数的使用
yangshuolll的专栏
07-08 716
虚函数的使用和纯虚函数的使用。 虚函数是在基类定义，然后子类重写这个函数后，基类的指针指向子类的对象，可以调用这个函数，这个函数同时保留这子类重写的功能。 纯虚函数是可以不用在基类定义，只需要声明就可以了，然后因为是纯虚函数，是不能产生基类的对象，但是可以产生基类的指针。 纯虚函数和虚函数最主要的区别在于，纯虚函数所在的基类是不能产生对象的，而虚函数的基类是可以产生对象的。 //
C++编程：多态与虚函数实现银行账户管理
1. **虚函数**：虚函数是C#中实现多态的基础，通过在基类中使用`virtual`关键字声明函数，使得该函数可以在派生类中被重写。这样，即使通过基类指针或引用来调用这个函数，实际执行的是派生类的版本，如果派生类中有...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值