多态和虚函数

最新推荐文章于 2024-08-08 16:20:44 发布
最新推荐文章于 2024-08-08 16:20:44 发布
阅读量750 收藏
点赞数
文章标签： 多态
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/JSRGFJZ/article/details/51152131
版权

多态与虚函数

在类的定义中，前面有virtual定义的即为虚函数
virtual关键字只用在定义类的函数声明时，写具体函数时不用。

class Base{
private:

public:
    virtual int get(){}
};

int base::get() {

}

对于派生类的对象可以赋值给基类，或者基类可以引用派生类。
如果基类指针或者引用指向基类对象，那么调用基类虚函数
如果基类指针或者引用指向派生对象，那么调用派生类对象

class A{
private:
public:
    virtual void Print() { cout << "A::print" << endl; }
};

class B:public A{
private:
public:
    virtual void Print() { cout << "B::print" << endl; }
};

class D :public A {
private:
public:
    virtual void Print() { cout << "D::print" << endl; }
};

class E :public B {
private:
public:
    virtual void Print() { cout << "E::print" << endl; }
};

int main() {
    A a; B b; E e; D d;
    A * pa = &a; B * pb = &b;
    D * pd = &d; E * pe = &e;
    pa->Print(); // a.Print()被调用，输出：A::Print
    pa = pb;
    pa->Print(); //b.Print()被调用，输出：B::Print
    pa = pd;
    pa->Print(); //d. Print ()被调用,输出：D::Print
    pa = pe;
    pa->Print(); //e.Print () 被调用,输出：E::Print
    return 0;
}

这里写图片描述

游戏编程实例

这里写图片描述

  • 非多态的实现方法
class CCreature{
private:
    int nPower; int nLifeValue;
public:
};

class CDragon:public CCreature{
private:
public:
    void Attack(CWolf *pWolf) {
        //表现攻击动作代码
        pWolf->Hurted(nPower);
        pWolf->FightBack(this);
    }

    void Attack(CGhost *pGhost) {
        //表现攻击动作代码
        pWolf->Hurted(nPower);
        pWolf->FightBack(this);
    }

    void Hurted(int nPower) {
        //表现受伤动作代码
        nLifeValue -= nPower;
    }

    void FightBack(CWolf *pWolf) {
        pWolf->Hurted(nPower / 2);
    }

    void FightBack(CGhost *pGhost) {
        pGhost->Hurted(nPower / 2);
    }
};

此时，n种生物，CDragon中会有n个Attack函数…..，其他类也如此。

  • 多态的实现方法
class CCreature{
private:
    int m_nPower; int m_nLifeValue;
public:
    virtual void Attack(CCreature *pCreature);
    virtual void Hurted(int nPower);
    virtual void FightBack(CCreature *pCreature);
};

class CDragon:public CCreature{
private:
public:
    virtual void Attack(CCreature *pCreature);
    virtual void Hurted(int nPower);
    virtual void FightBack(CCreature *pCreature);
};

void CDragon::Attack(CCreature *pCreature) {
    //表现攻击动作代码
    pCreature->FightBack(this);
    pCreature->Hurted(m_nPower);
}

void CDragon::Hurted(int nPower) {
    //表现受伤代码
    m_nLifeValue -= nPower;
}

void CDragon::FightBack(CCreature *pCreature) {
    //表现反击动作代码
    pCreature->Hurted(m_nPower / 2);
}

更多实例

  • 几何形体处理程序

输入： n 个数目，即n行，每行以c开头
c:R-矩形-后面接长和宽
c:C-圆形-后面接半径
c:T-三角形-后面接三条边
输出：
从小到大输出几何形体的种类和面积

class CShape
{
private:
public:
    virtual double Area() = 0;//纯虚函数
    virtual void PrintInfo() = 0;//纯虚函数
};

class CRectangle:public CShape{
private:
public:
    int w, h;
    virtual double Area();
    virtual void PrintInfo();
};

class CCircle:public CShape{
private:
public:
    int r;
    virtual double Area();
    virtual void PrintInfo();
};

class CTriangle:public CShape{
private:
public:
    int a, b, c;
    virtual double Area();
    virtual void PrintInfo();
};

double CRectangle::Area() {
    return w*h;
}

void CRectangle::PrintInfo() {
    cout << "Rectangle:" << Area() << endl;
}

double CCircle::Area() {
    return 3.14*r*r;
}

void CCircle::PrintInfo() {
    cout << "Circle:" << Area() << endl;
}

double CTriangle::Area() {
    double p = (a + b + c) / 2;
    return sqrt(p*(p-a)*(p-b)*(p-c));
}

void CTriangle::PrintInfo() {
    cout << "Triangle:" << Area() << endl;
}

CShape *pShapes[100];
int MyCompare(const void *s1, const void *s2);

int main() {
    int i, n;
    CRectangle *pr; CTriangle *pt; CCircle *pc;

    cin >> n;
    for (int i = 0; i <n;i++) {
        char c;
        cin >> c;
        switch (c){
        case 'R':
            pr = new CRectangle();
            cin >> pr->w >> pr->h; 
            pShapes[i] = pr;
            break;
        case 'C':
            pc = new CCircle();
            cin >> pc->r;
            pShapes[i] = pc;
            break;
        case 'T':
            pt = new CTriangle();
            cin >> pt->a >> pt->b >> pt->c;
            pShapes[i] = pt;
            break;
        }
    }

    qsort(pShapes, n, sizeof(CShape*), MyCompare);
    for (int i = 0; i < n;i++) {
        pShapes[i]->PrintInfo();
    }
    return 0;
}

int MyCompare(const void*s1,const void*s2){
  double a1,a2;
  CShape **p1;//s1,s2是 void*，不可写“*s1”来取得s1指向的内容
  CShape **p2;
  //s1,s2是指向 pShapes 数组中的元素，元素类型是CShape*，即 s1，s2是指向指针的指针
  p1 = (CShape**)s1;
  p2 = (CShape**)s2;
  //那么想取得他们所指向的内容只能.*p1
  a1 = (*p1)->Area();
  a2 = (*p2)->Area();
  if (a1<a2) {
      return -1;
  }else if (a2<a1){
      return 1;
  }else{
      return 0;
  }
}

这里写图片描述

这里写图片描述
- 2

class Base {
public:
    void fun1() { fun2(); }
    virtual void fun2() { cout << "Base::fun2()" << endl; }
};
class Derived :public Base {
public:
    virtual void fun2() { cout << "Derived:fun2()" << endl; }
};
int main() {
    Derived d;
    Base * pBase = &d;
    pBase->fun1();
    return 0;
}

结果

这里写图片描述

可以见下一段代码：

class Base {
public:
    void fun1() { fun2(); }
    virtual void fun2() { cout << "Base::fun2()" << endl; }
};
class Derived :public Base {
public:
    virtual void fun2() { cout << "Derived:fun2()" << endl; }
};
int main() {
    Base d;
    Base * pBase = &d;
    pBase->fun1();
    return 0;
}

这里写图片描述

再见一段代码

class Base {
public:
    void fun1() { this->fun2(); } //this是基类指针，fun2是虚函数，所以是多态
    virtual void fun2() { cout << "Base::fun2()" << endl; }
};
class Derived :public Base {
public:
    virtual void fun2() { cout << "Derived:fun2()" << endl; }
};
int main() {
    Derived d;
    Base * pBase = &d;
    pBase->fun1();
    return 0;
}

这里写图片描述

总结：在构造函数和析构函数中调用虚函数，不是多态。编译时即可确定，调用的函数是自己的类或基类中定义的函数，不会等到运行时候才决定调用自己的还是派生的。

小quiz

class myclass {
public:
    virtual void hello() { cout << "hello from myclass" << endl; };
    virtual void bye() { cout << "bye from myclass" << endl; }
};
class son :public myclass {
public:
    void hello() { cout << "hello from son" << endl; };
    son() { hello(); };
    ~son() { bye(); };
};
class grandson :public son {
public:
    void hello() { cout << "hello from grandson" << endl; };
    void bye() { cout << "bye from grandson" << endl; }
    grandson() { cout << "constructing grandson" << endl; };
    ~grandson() { cout << "destructing grandson" << endl; };
};

int main() {
    grandson gson;
    son *pson;
    pson = &gson;
    pson->hello(); //多态
    return 0;
}

这里写图片描述

解释：从一开始定义grandson类型 gson，就要从顶端开始执行构造函数。好，myclass调用默认构造函数，对于son，则调用hello()函数，注意，此时不是多态，因为是在构造函数里面，所以生成 “hello from son”，接着调用grandson的构造函数，生成“constructing grandson”；接着定义son指针，并且让pson指向gson，所以到pson->hello()的时候，打印出”hello from grandson”，此时是多态哦。最终调用各自析构函数，由底到顶。

多态实现原理

class Base {
public:
    int i;
    virtual void Print() { cout << "Base:Print"; }
};
class Derived : public Base {
public:
    int n;
    virtual void Print() { cout << "Drived:Print" << endl; }
};
int main() {
    Derived d;
    cout << sizeof(Base) << "," << sizeof(Derived) << endl; ;
    return 0;
}

这里写图片描述

这里写一下自己的理解，base里面含有int类型，大小是4个字节，因为每一个有虚函数的类（或者由虚函数的类的派生类）都有一个虚函数表，该类的任何对象中都存放着虚函数表的指针，所以多出来的4个字节就是存放虚函数表的地址的。
这里写图片描述

一开始我在想，为什么函数不占字节呢，其实，如果在基类中加入函数也是不占据字节的，不信，请看：

class Base {
public:
    int i;
    void print2() { cout << "Base:Print-1"; }
    virtual void Print() { cout << "Base:Print"; }
};
class Derived : public Base {
public:
    int n;
    virtual void Print() { cout << "Drived:Print" << endl; }
};
int main() {
    Derived d;
    cout << sizeof(Base) << "," << sizeof(Derived) << endl; ;
    return 0;
}

这里写图片描述

因此，对于多态的原理，用以下两张图片即可解释：

这里写图片描述

这里写图片描述

即：多态的函数调用语句被编译成一系列根据基类指针所指向的（或者基类引用的）对象中存放的虚函数的地址，在虚函数表中查找虚函数地址，并调用相关指令。

虚析构函数

class CSon {
public: ~CSon() { };
};
class CGrandson :public CSon {
public: ~CGrandson() { };
};
int main() {
    CSon *p = new CGrandson();
    delete p;
    return 0;
}

通过基类的指针删除派生类对象，只会调用基类的析构函数，这样会导致内存未被完全清除

因此，我们希望能够先调用派生类的析构函数，再调用基类析构函数（不可以将虚函数作为构造函数）

  • 1
class son{
public:
~son() { cout<<"bye from son"<<endl; };
};
class grandson : public son{
public:
~grandson(){ cout<<"bye from grandson"<<endl; };
};
int main(){
son *pson;
pson=new grandson;
delete pson;
return 0;
}

这里写图片描述

  • 2
class son {
public:
    virtual ~son() { cout << "bye from son" << endl; };
};
class grandson : public son {
public:
    ~grandson() { cout << "bye from grandson" << endl; };
};
int main() {
    son *pson;
    pson = new grandson;
    delete pson;
    return 0;
}

这里写图片描述

纯虚函数和抽象类

  • 纯虚函数

纯虚函数：没有函数体的虚函数

class A {
private:
    int a;
public:
    virtual void Print() = 0; //纯虚函数 
    void fun() { cout << “fun”; }
};
  • 抽象类

定义：包含纯虚函数的类
1、只能作为基类来派生新类使用
2、不能创建抽象类的对象
3、抽象类可以进行指针和引用–>由抽象类派生出来的对象

A a; // 错, A 是抽象类, 不能创建对象
A * pa; // ok, 可以定义抽象类的指针和引用
pa = new A; //错误, A 是抽象类, 不能创建对象
  • 纯虚函数和抽象类

抽象类中

  1. 成员函数可以调用纯虚函数
  2. 构造/析构函数不能调用纯虚函数

如果一个类从抽象类派生而来，只有当他实现基类中所有纯虚函数，才能成为非抽象类。
实现—诸如添加一个空括号等

class A {
public:
    virtual void f() = 0; //纯虚函数
    void g() { this->f(); } //ok
    A() { } //f( ); // 错误
};
class B : public A {
public:
    void f() { cout << "B: f()" << endl; }
};
int main() {
    B b;
    b.g();
    return 0;
}

这里写图片描述

顺其自然__
关注
详细分析C++ 多态和虚函数
08-18
虚函数可以分为两种类型：虚函数和纯虚函数。虚函数是在基类中声明的函数，它可以在派生类中重新定义。纯虚函数是在基类中声明的虚函数，但是它不能在基类中给出有意义的实现。纯虚函数的实现需要在派生类中重新定义...
虚函数和多态
Ryzen3的博客
04-14 2368
虚函数和多态的基础知识
多态与虚函数
Hustle Everyday
03-07 961
一、什么是多态 多态就是向不同的对象发送同一个消息，不同的对象在接收时会产生不同的行为。也就是说，每个对象可以用自己的方式去响应共同的消息。使用相同的代码实现不同的动作，体现了面向对象编程的优越性。 在C++中，多态就是利用基类指针指向子类实例，通过基类指针调用子类（虚）函数从而实现“一个接口，多种形态”的效果。 简单的说就是，实现了一个函数会根据传入参数的不同有不同的功能，比如： vo...
C++知识点总结：5.多态和虚函数（自用）
最新发布
目前涉及领域：目标检测，语义分割以及数字图像处理
08-08 786
通过学习"C语言中文网"中第五章多态和虚函数的内容，来总结的C++知识点。
C++专题：多态性与虚函数（详细！）
m0_70983574的博客
07-21 2394
对C++的多态性和虚函数进行了详细介绍
浅谈多态性与虚函数
分享一些自己的学习心得体会和总结！
10-15 807
虚函数的作用是允许在派生类中重新定义与基类同名的函数，并且可以通过基类指针或引用来访问基类和派生类中的同名函数。
C++——多态|虚函数|重写|虚表
博主qq1077644249
02-13 3172
1. 多态的概念 1.1 概念 2. 多态的定义及实现 2.1多态的构成条件 2.2 虚函数 2.3虚函数的重写 虚函数重写的三个例外： 2.4 普通调用和多态调用： 2.5 C++11 override 和 final 2.6 重载、虚函数的覆盖(重写)、隐藏(重定义)的对比 3. 抽象类(有关纯虚函数) 3.1 概念 3.2 接口继承和实现继承 4.多态的原理 4.1虚函数表 派生类的虚表生成流程： 虚函数存在哪的？**虚表**存在哪的？ 4.2多态的原理 4.3 动态绑定与静态绑定 5.单继承
多态和虚函数[参照].pdf
10-12
静态多态主要通过函数重载和运算符重载实现，而动态多态则依赖于虚函数。C++中，虚函数是实现动态多态的关键。当基类指针或引用指向子类对象时，通过虚函数调用，能够根据实际的对象类型调用相应的成员函数，而不是...
C++ 多态和虚函数 高清PDF
08-15
多态性（在C + +中用虚函数实现）是面向对象程序设计语言继数据抽象和继承之后的第三个基本特征。 它提供了与具体实现相隔离的另一类接口，即把“ w h a t”从“h o w”分离开来。多态性提高了代码的组织性和可读性...
多态和虚函数[收集].pdf
10-13
在C++编程语言中，多态性和虚函数是面向对象设计的重要组成部分，它们共同促进了类的继承和代码的复用。多态性是指一个接口可以有多种不同的行为，这使得程序能够以统一的方式处理不同类型的对象。虚函数是实现多态...
多态 + 虚函数
Hi海底的博客
05-18 371
学习博客： 虚函数 CSDN- 虚函数 多态 多态是面向对象的三大特征之一，其它两大特征分别是 封装 和 继承。 面向对象的三大特征：封装、多态、继承 所谓 多态，简单来说，就是当发出一条命令时，不同的对象接收到同样的命令后所做出的动作是不同的。 书本上的定义：指相同对象收到不同消息或不同对象收到系统消息时产生不同的动作。 分为动态多态和静态多态： 静态多态 静态多态，也叫 早绑定 看如下实例：定义一个矩形类：Rect，其中有两个同名成员函数：calcArea()，显然 二者互为重载.
C++ 入门11：虚函数和多态
LF__plus的博客
07-14 788
在前面的文章学习中，我们了解了类和对象的基础知识、构造函数、拷贝构造函数、静态成员、常量成员、运算符重载、友元函数、友元类以及继承和派生类。今天，我们将学习 C++ 中的虚函数和多态。多态是面向对象编程中的一个重要概念，它使得相同的操作可以作用于不同的对象，从而提高代码的灵活性和可扩展性。
【C++入门】(纯)虚函数和多态、抽象类、接口
weixin_42031299的博客
10-28 1678
(1)当基类含有1个或多个虚函数时，其析构函数需要声明为virtual虚函数；(2)将析构函数定义为虚函数，可以保证派生类析构时能调用正确的析构函数；(1)虚函数的作用是实现面向对象的多态效果，让成员函数在运行时动态解析和绑定具体的执行函数；(2)将成员函数定义为virtual虚函数是有额外开销的，因为要在运行时动态绑定；如果是普通函数，在编译时就可以确定并绑定完成；
c++复习之多态与虚函数
guangod的博客
07-05 398
多态与虚函数多态概念使用普通成员函数实现多态虚函数使用虚析构函数纯虚函数和抽象类抽象类虚基类 多态 面向对象3种机制之一（封装、继承、多态），提高程序的可读性，可扩展性和可重用性。 概念 不同对象可以调用相同名称的函数，但可导致完全不同的行为的现象。 多态实现的是接口的复用。不论传递过来是哪个类的对象，函数都能够通过同一个接口调用到适应各自对象的实现方法。 使用 编译时多态（静态多态）：即函数重载，在编译时就能绑定调用语句与调用函数入口地址。 运行时多态（动态多态）函数调用与代码入口地址的绑定需要在运行时刻
【多态性与虚函数的知识点】
weixin_64993156的博客
03-23 447
总结：通过这次实验了解到，如果在基类中定义了没有参数的构造函数,那么在定义派生类构造函数时可以不写基类构造函数,在调用派生类构造函数时、系统会自动首先调用基类的默认构造函数、如果在基类或子对象类型的声明中定义了参数的构造函数、那么就必须显式地定义派生类构造函数。多态性与虚函数的知识点，虚函数、虚函数的作用、虚函数的声明方法、使用方法、虚函数使用注意、虚析构函数，纯虚函数与抽象类
虚函数与多态（一）
INGNIGHT的专栏
05-26 996
1.多态 （1）多态性是面向对象程序设计的重要特征之一。 （2）多态性是指发出相同的消息被不同类型的对象接收时，有可能导致完全不同的行为。 （3）多态的实现：函数重载，运算符重载，模板，虚函数 2.静态绑定与动态绑定 （1）静态绑定：绑定过程出现在编译阶段，在编译期就已确定要调用的函数。 （2）动态绑定：绑定过程工作在程序运行时执行，在程序运行时才确定将要...
c++继承、多态和虚函数
07-28
C++中的继承、多态和虚函数是面向对象编程的重要概念。 继承是指一个类可以从另一个类继承属性和方法。子类可以继承父类的公有成员和保护成员，但不能继承私有成员。通过继承，子类可以重用父类的代码，并且可以添加自己的特定功能。继承可以实现代码的重用和层次化的设计。 多态是指同一个函数可以根据不同的对象调用不同的实现。多态可以通过虚函数来实现。虚函数是在基类中声明为虚拟的函数，它可以在派生类中被重写。当通过基类指针或引用调用虚函数时，实际调用的是派生类中的实现。这样可以实现动态绑定，即在运行时确定调用的函数。 虚函数的原理是通过虚函数表来实现的。每个包含虚函数的类都有一个虚函数表，其中存储了虚函数的地址。当调用虚函数时，编译器会根据对象的类型在虚函数表中查找对应的函数地址并调用。 综上所述，C++中的继承、多态和虚函数是实现面向对象编程的重要机制，它们可以提高代码的灵活性和可扩展性。 #### 引用[.reference_title] - *1* *3* [C++多态之 虚函数和虚函数表](https://blog.csdn.net/weixin_46053588/article/details/121231465)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^control_2,239^v3^insert_chatgpt"}} ] [.reference_item] - *2* [c++多态及虚函数表内部原理实战详解](https://blog.csdn.net/bitcarmanlee/article/details/124830241)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^control_2,239^v3^insert_chatgpt"}} ] [.reference_item] [ .reference_list ]
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值