菜鸟学习历程【31】多态

最新推荐文章于 2021-02-27 13:08:51 发布
最新推荐文章于 2021-02-27 13:08:51 发布
阅读量178 收藏
点赞数
分类专栏： C++ 文章标签： 多态 继承 虚继承
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/leessang_bo/article/details/79069332
版权

多态

概念：同样的调用语句有多种不同的表现形式。
通俗的来说：根据传入的对象类型的不同，调用不同的派生类的相应函数。

多态实现的条件：
1.要存在继承关系；
2.对虚函数的重写；
3.基类指针（引用）指向派生类对象

静态联编与动态联编

静态联编：程序匹配，连接在编译阶段实现，也称为早期联编（在编译的时候，就知道了该去调用谁）
例如：函数重载

动态联编：程序联编推迟到运行时进行，也称为晚期联编（在执行时，才会知道调用那一个函数）
例如：switch 和 if 语句

我们通过动物类来说明：

#include <iostream>

using namespace std;

// 动物： 基类
class Animal
{
public:
    Animal(int age, char *name)
    {
        this->age  = age;
        this->name = name;
    }
    void sleep()
    {
        printf ("动物睡觉\n");
    }

    void print()
    {
        printf ("age = %d, name = %s\n", age, name);
    }
private:
    int age;
    char *name;
};

class Cat:public Animal
{
public:
    Cat(int age, char *name):Animal(age, name)
    {

    }
    void sleep()
    {
        printf ("猫 趴着睡觉\n");
    }
};

class Fish:public Animal
{
public:
    Fish(int age, char *name):Animal(age, name)
    {

    }
    void sleep()
    {
        printf ("鱼 睁着眼睡觉\n");
    }
};

void func(Animal *p)
{
    p->sleep();
}

int main()
{
    Animal *pa = new Animal(2, "动物");
    Cat    *pc = new Cat(3, "猫");
    Fish   *pf = new Fish(2, "鱼");

    func(pa);   //动物睡觉
    func(pc);   //动物睡觉
    func(pf);   //动物睡觉

    return 0;
}

分析：
基类中的 sleep（）函数是一个普通类型的函数，并且 func 的形参为 Animal 类的指针，虽然 pc 和 pf 是一个指向 猫类 和 鱼类 的指针，调用函数 func 时，基类指针指向了派生类的对象，基类指针的本质依旧是 Animal*。因此，在编译的时候就明确了，该调用哪一个函数，这是一个静态联编。
实际上，我们希望能根据传入的指针的不同，调用不同的sleep();
那么，我们需要使用 virtual 来修饰基类的成员函数，以此来实现多态。

#include <iostream>

using namespace std;

// 动物： 基类
class Animal
{
public:
    Animal(int age, char *name)
    {
        this->age  = age;
        this->name = name;
    }
    virtual void sleep()
    {
        printf ("动物睡觉\n");
    }

    void print()
    {
        printf ("age = %d, name = %s\n", age, name);
    }
private:
    int age;
    char *name;
};

class Cat:public Animal
{
public:
    Cat(int age, char *name):Animal(age, name)
    {

    }
    void sleep()
    {
        printf ("猫 趴着睡觉\n");
    }
};

class Fish:public Animal
{
public:
    Fish(int age, char *name):Animal(age, name)
    {

    }
    void sleep()
    {
        printf ("鱼 睁着眼睡觉\n");
    }
};

void func(Animal *p)
{
    p->sleep();
}

int main()
{
    Animal *pa = new Animal(2, "动物");
    Cat    *pc = new Cat(3, "猫");
    Fish   *pf = new Fish(2, "鱼");

    func(pa);  // 动物睡觉
    func(pc);  // 猫 趴着睡觉
    func(pf);  // 鱼 睁着眼睡觉

    return 0;
}

此时，我们将基类中的 sleep（） 函数声明为虚函数后，再通过基类指针去调用函数时，会根据传入对象的不同，找到相应的函数来执行。
多态的原理，随后为大家讲解。

虚析构函数

通过基类指针释放派生类对象， 基类的析构函数一定要是 虚析构函数。
举个例子说明一下：

#include <iostream>

using namespace std;

// 基类
class A
{
public:
    A()
    {
        printf ("A 的构造函数\n");
    }
    ~A()
    {
        printf ("A 的析构函数\n");
    }
};

class B:public A
{
public:
    B()
    {
        p = new char[20];
        printf ("B 的构造函数\n");
    }
    ~B()
    {
        if (p != NULL)
            delete[] p;
        printf ("B 的析构函数\n");
    }

private:
    char *p;
};

void func(A *pa)
{
    delete pa;
}


int main()
{
    A *pa = new B;
    func(pa); 

    return 0;
}

运行结果是：
A 的构造函数
B 的构造函数
A 的析构函数
发现，没有了B的析构函数，这样会造成内存的泄漏，为什么会出现这种现象呢？

首先，我们得明确构造和析构的一个基本特性：

构造函数：从当前类往上找 父类 ⇒ 最上层的父类， 从最上层的父类开始构造（调用构造函数），类似于前序递归
析构函数：从当前类开始析构 析构完 沿着继承路径往上找父类 析构父类 ⇒ 找到最上层的父类 析构，类似于后序递归

那么，对于上面的程序的结果，原因在于，执行语句“A *pa = new B;”定义了一个 B 类的对象，那么会先调用 基类的 构造函数，再调用自身的构造函数，再调用 func（）函数时，释放的是基类的指针，它认为基类的指针是当前的对象，所以调用的是基类的构造函数。

Tips：

char *ptr = "abcdefg";

void printS(char *p) 
{   
    if (*p == '\0') 
        return ;
    printf ("%c", *p);

    printS(p+1);   // 递归
    //printf ("%c", *p);
}

// 先打印，再递归的，称为后序递归，打印结果：abcdefg
// 先递归，再打印的，称为前序递归，打印结果：gfedcba

为了解决这个问题，我们只需要将基类的析构函数声明为虚函数。

class A
{
public:
    A()
    {
        printf ("A 的构造函数\n");
    }
    virtual ~A()
    {
        printf ("A 的析构函数\n");
    }
};

多态的原理

多态通过一个虚函数指针（vfptr）来实现。这个虚函数指针指向一个虚函数表，这张表里存放了该类对应的虚函数。
我们还是使用动物类来说明：

class Animal
{
public:
    Animal(int age, char *name)
    {
        this->age  = age;
        this->name = name;
    }
    virtual void sleep()
    {
        printf ("动物睡觉\n");
    }
    virtual void eat()
    {
        printf ("动物吃饭\n");
    }
    void print()
    {
        printf ("age = %d, name = %s\n", age, name);
    }
private:
    int age;
    char *name;
};

class Cat:public Animal
{
public:
    Cat(int age, char *name):Animal(age, name)
    {

    }
    void sleep()
    {
        printf ("猫 趴着睡觉\n");
    }
};

我们知道 基类中的 sleep（） 和 eat（）函数是一个虚函数，那么基类的虚函数指针就会指向一张虚函数表，这张表由编译器保管。
这里写图片描述

那么，当 Cat 类继承 Animal 时，由于 Cat 类中有与 Animal 类中的虚函数同名的函数，因此 Cat类中的同名函数也是虚函数，但与基类有所不同的是，派生类中的虚函数指针不在指向基类中虚函数表，而是指向自己的虚函数表。
这里写图片描述
因此，当调用 func（）函数时，编译器会根据对象的虚函数指针找到对应的虚函数表，再找到虚函数。
注意：由于虚函数在编译的时候，并不知道谁在调用，所以会在执行的时候才会确定，因此是动态联编，并且效率会低于一般的函数。

虚继承与虚函数共存的情况

（以下内存模型的结果，本人通过 VS2010 和 VS2015进行验证）
1.基类有虚函数，派生类中没有虚函数，普通继承时

#include <iostream>

using namespace std;

class AA
{
public:
    AA(int a = 0)
    {
        this->a = a;
    }
    virtual void print()
    {
        printf("AA 的print函数\n");
    }
private:
    int a;
};

class BB :public AA
{
public:
    BB(int b) :AA(1)
    {
        this->b = b;
    }
    void show()
    {
        printf("BB 的show函数\n");
    }
private:
    int b;
};

int main()
{
    BB b(2);

    printf("sizeof b is %d\n", sizeof(b));

    b.print();
    return 0;
}

执行结果：
sizeof b is 12
AA 的print函数

来看一下内存模型：
这里写图片描述
我们看到对象 b 所占内存为 12 字节，查看一下内存分布可以看出来，地址从低到高依次是 vfptr，a，b，此时虚函数表里存放的是 AA 中的 print 函数。

2.基类有虚函数，派生类中没有虚函数，虚继承时

#include <iostream>

using namespace std;

class AA
{
public:
    AA(int a = 0)
    {
        this->a = a;
    }
    virtual void print()
    {
        printf("AA 的print函数\n");
    }
private:
    int a;
};

class BB :virtual public AA
{
public:
    BB(int b) :AA(1)
    {
        this->b = b;
    }
    void show()
    {
        printf("BB 的show函数\n");
    }
private:
    int b;
};

int main()
{
    BB b(2);

    printf("sizeof b is %d\n", sizeof(b));

    b.print();
    return 0;
}

执行结果：
sizeof b is 16
AA 的print函数

内存模型：

这里写图片描述
在这里，说明一下虚函数指针的存放位置，一般 vfptr 都会与自身类的成员在内存上连续存放，就像这里的 vfptr 和 a

3.基类没有虚函数，派生类中有虚函数，普通继承时

#include <iostream>

using namespace std;

class AA
{
public:
    AA(int a = 0)
    {
        this->a = a;
    }
    void print()
    {
        printf("AA 的print函数\n");
    }
private:
    int a;
};

class BB :public AA
{
public:
    BB(int b) :AA(1)
    {
        this->b = b;
    }
    virtual void show()
    {
        printf("BB 的show函数\n");
    }
private:
    int b;
};

int main()
{
    BB b(2);

    printf("sizeof b is %d\n", sizeof(b));

    return 0;
}

运行结果：
sizeof b is 12

内存分析：
这里写图片描述

4.基类没有虚函数，派生类中有虚函数，虚继承时

#include <iostream>

using namespace std;

class AA
{
public:
    AA(int a = 0)
    {
        this->a = a;
    }
    void print()
    {
        printf("AA 的print函数\n");
    }
private:
    int a;
};

class BB :virtual public AA
{
public:
    BB(int b) :AA(1)
    {
        this->b = b;
    }
    virtual void show()
    {
        printf("BB 的show函数\n");
    }
private:
    int b;
};

int main()
{
    BB b(2);

    printf("sizeof b is %d\n", sizeof(b));

    return 0;
}

运行结果：
sizeof b is 16
内存分析：
这里写图片描述

5.基类有虚函数，派生类中有虚函数，普通继承时
（1）派生类 中的 虚函数 与 基类 中的虚函数不同名时

#include <iostream>

using namespace std;

class AA
{
public:
    AA(int a = 0)
    {
        this->a = a;
    }
    virtual void print()
    {
        printf("AA 的print函数\n");
    }
private:
    int a;
};

class BB :public AA
{
public:
    BB(int b) :AA(1)
    {
        this->b = b;
    }
    virtual void show()
    {
        printf("BB 的show函数\n");
    }
private:
    int b;
};

int main()
{
    BB b(2);

    printf("sizeof b is %d\n", sizeof(b));

    b.print();
    return 0;
}

运行结果：
sizeof b is 12
AA 的print函数

内存模型：
这里写图片描述

（2）派生类 中的 虚函数 与 基类 中的虚函数同名时

#include <iostream>

using namespace std;

class AA
{
public:
    AA(int a = 0)
    {
        this->a = a;
    }
    virtual void print()
    {
        printf("AA 的print函数\n");
    }
private:
    int a;
};

class BB :public AA
{
public:
    BB(int b) :AA(1)
    {
        this->b = b;
    }
    virtual void print()
    {
        printf("AA 的print函数\n");
    }
    virtual void show()
    {
        printf("BB 的show函数\n");
    }
private:
    int b;
};

int main()
{
    BB b(2);

    printf("sizeof b is %d\n", sizeof(b));

    b.print();
    b.show();
    return 0;
}

运行结果：
sizeof b is 12
BB 的print函数
BB 的show函数
这里写图片描述

这两种情况其实是一样的，唯一的区别在于 虚函数指针 指向的虚函数列表中虚函数不同，当派生类中没有与基类虚函数同名的函数时，虚函数列表里有 基类 的虚函数，但当派生类中有与基类虚函数同名的函数时，虚函数列表里有 派生类 的虚函数

6.基类有虚函数，派生类中有虚函数，虚继承时
（1）派生类 中的 虚函数 与 基类 中的虚函数不同名时

#include <iostream>

using namespace std;

class AA
{
public:
    AA(int a = 0)
    {
        this->a = a;
    }
    virtual void print()
    {
        printf("AA 的print函数\n");
    }
private:
    int a;
};

class BB :virtual public AA
{
public:
    BB(int b) :AA(1)
    {
        this->b = b;
    }
    virtual void show()
    {
        printf("BB 的show函数\n");
    }
private:
    int b;
};

int main()
{
    BB b(2);

    printf("sizeof b is %d\n", sizeof(b));

    b.print();
    b.show();
    return 0;
}

运行结果：
sizeof b is 20
AA 的print函数
BB 的show函数

内存分析：
此时的 虚基类指针 的第一个参数为 -4 ，因为当前对象的 虚函数指针 在最上面。对象 b 的虚函数表中有两个函数，一个是 基类的 print 函数，一个是 自己的 show 函数，并且 自己的 show 函数 在内存中的位置 在基类的 print 函数之前，而AA 的虚函数表中 只有自己的 print 函数。
这里写图片描述

（2）派生类 中的 虚函数 与 基类 中的虚函数同名时

#include <iostream>

using namespace std;

class AA
{
public:
    AA(int a = 0)
    {
        this->a = a;
    }
    virtual void print()
    {
        printf("AA 的print函数\n");
    }
private:
    int a;
};

class BB :virtual public AA
{
public:
    BB(int b) :AA(1)
    {
        this->b = b;
    }
    virtual void print()
    {
        printf("BB 的print函数\n");
    }
    virtual void show()
    {
        printf("BB 的show函数\n");
    }
private:
    int b;
};

int main()
{
    BB b(2);

    printf("sizeof b is %d\n", sizeof(b));

    b.print();
    b.show();
    return 0;
}

运行结果：
sizeof b is 24
BB 的print函数
BB 的show函数

内存分析：
这里写图片描述

L_R
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
c#基础学习之多态
12-25
先说说多态吧：1.基类继承式多态如书中所说，基类继承式多态的关键是继承体系的设计与实现。书中举了个简单的列子 代码如下: Files myFile=new WORDFile(); myFile.open(); myFile是一个父类Files变量，...
Java学习历程（八）：接口与多态
luojianjane的博客
08-22 103
一、接口是实现多态的有效措施，接口的出现是因为有些类是不需要创建实例的，它们只需要存在一个抽象的定义，之后再让子类去继承它（可以重写父类的方法）。 编译器是不会让我们去实例化抽象类的： 二、为什么要设计抽象的方法? 因为在抽象类中的某些方法行为在没有特定的运行时是不会有任何的意义的。也就是说，没有任何通用的实现是可行的。 抽象的方法是没有实体的。如果声明一个抽象的方法，就必须将类也...
java菜鸟进阶宝典_Java菜鸟进阶历程--体会
weixin_29720641的博客
02-27 143
0.前言时间是一场有去无回的旅行，转眼间这个学期的Java课程就画上了句号(但学习Java的道路才刚刚开始)，所以本次博客来说说菜鸟学习Java这门课程的体会。1.初识Java的陌生本学期第三周，我正式的接触了Java。从配置jdk和安装eclipse开始(那时侯我想Java应该会很难，安装一个编程工具就有点复杂)，于是怀着有些担心的心情开始了第一节Java课程(网课)。第一节课老师也就是讲了一下...
Java学习历程（7）：继承与多态
luojianjane的博客
08-22 68
一、怎样去判断两者应不应该设计继承关系呢？ 二、扩充和延伸。 三、继承学习要点。 四、多态的本质。 传参时也可以体现出多态性。 没有私有类这种东西，因为类写出来是要被用的。 五、控制类的继承权限方法。 一般来说，我们都不会写出被标志为final的类，除非你想保证你写的方法之后都不要被改写。 六、override覆盖可以实现多态。覆盖需要满足一定的规则。 ...
菜鸟学习历程【27】面向对象编程（1）
leessang_bo的博客
01-12 205
面向过程编程 与 面向对象编程 什么叫做面向过程编程？ 通俗的来说，这种编程风格如同从上到下，从左到右。首先，要考虑遵循的步骤，然后考虑如何表现这些数据。 那么什么又是面向对象编程呢？ 从用户的角度出发考虑对象，描述对象所需的数据以及描述用户与数据进行交互所需要的操作。完成对接口的描述后，需要确定如何实现接口和数据存储。 面向对象编程 特点：封装、继承、多态 封装：数据进行隐
Java学习笔记（多态封装）
03-10
内容为本人学习java多态封装时整理的基础知识笔记，内容包括java中的多态和封装
多态学习-什么是多态及代码
01-25
多态
学习JavaScript设计模式(多态)
11-22
多态的实际含义是：同一操作作用于不同的对象上面，可以产生不同的解释和不同的执行结果。换句话说，给不同的对象发送同一个消息的时候，这些对象会根据这个消息分别给出不同的反馈。 从字面上来理解多态不太容易，...
《头脑王者》——在线排位答题系统源码
leessang_bo的博客
02-13 8285
声明：这些源码尚有可完善之处，因本人能力尚浅，如有错误，还望指正，谢谢！ 服务器端 1. widget.h &amp; widget.cpp //widget.h #ifndef WIDGET_H #define WIDGET_H #include &lt;QWidget&gt; #include &lt;QTcpServer&gt; // tcp服务器类 #include &...
《头脑王者》--在线排位答题系统构思
leessang_bo的博客
02-12 3382
《头脑王者》是一款在线排位制答题小应用，我们希望在学习完 QT 后，能做一个类似的应用，那么在真正开始着手之前，将功能细化、拆分，待整体思路清晰后，再开始写代码。 抛开 排位制 和 在线 两个修饰语，答题这个功能，我们还是比较熟悉的。 如何答题？ 在学完 C++ 的容器后，对数据的存储有了更加方便的选择，在 QT 中 进行“单机版”模拟时，我们先使用链表这个容器保存题目、选项、正确答案、实际...
菜鸟学习历程【32】函数模板与类模板
leessang_bo的博客
01-20 602
函数模板 所谓函数模板，实际上是建立一个通用函数，其函数类型和形参类型不具体指定，用一个虚拟的类型来代表。这个通用函数就称为函数模板。凡是函数体相同的函数都可以用这个模板来代替，不必定义多个函数，只需在模板中定义一次即可。在调用函数时系统会根据实参的类型来取代模板中的虚拟类型，从而实现了不同函数的功能。 模板：将 算法 与 数据类型 相分离； 定义： template T> voi
菜鸟学习历程【25】C++入门
leessang_bo的博客
01-05 266
C++入门命名空间将全局空间进行划分，全局空间也被称为默认命名空间，命名空间可以相互嵌套。例如：这里在全局空间中，开辟了三个大的命名空间分别为Name1，Name2， Name3，其中Name3中又有两个命名空间Name4和Name5； //命名空间的定义，命名空间内可以写变量、函数、宏定义 namespace Name1 { int a; }namespace Name2 { i
菜鸟学习历程【30】继承与派生
leessang_bo的博客
01-15 229
继承与派生 类之间的关系：使用、包含、继承 使用：一个类使用了另一个类的对象，友元类、 包含：一个类中有另一个类的对象，例如，圆类 和 点类 继承：一个类是另一个类的特殊实例 继承是使用已经编写好的类来创建新类，新的类具有原有类的所有属性和操作，也可以在原有的基础上进行增补。 通常我们将新类称为派生类（子类），将被继承的类称为基类（父类）; 语法： class 派生类: 继承权
菜鸟学习历程【26】引用、内联函数、默认参数、函数重载
leessang_bo的博客
01-07 226
引用我们定义一个整型变量 a ，并赋值10；int a = 10;整型数据占4个字节，a是一个标识符，这个标识符代表这个空间，对这个标识符的操作，就是对这块空间的操作。那么引用呢，就是给这段空间起一个小名，原本它被称为 a ，现在我们也可以叫它其他的名字。引用的格式：类型 & 小名 = 原名；例如：int &b = a; //b就是对a的引用别名依赖于原名，普通引用必须初始化。int &c;
菜鸟学习历程【33】类型转换、异常
leessang_bo的博客
01-23 214
类型转换 在 c语言 中，类型转换时很简单的，大致分为两种： 1.隐式转换 char c = 'A'; int a = c; // a = 65 2.强制转换 double d = 1.2; int a = (int) d; // 丢失小数部分 这会导致两个问题的出现： 1）任何类型之间都可以转换，编译器很难判断正确性； 2）在源码中无法快速定位所有使用强制类型转换的语
菜鸟学习历程【29】运算符重载
leessang_bo的博客
01-12 193
我们知道，函数重载就是对一个已有的函数赋予新的含义，使之实现新功能。 那么对于运算符而言，也可以重载实现不同的功能。 不可重载的运算符有（用括号括起来）： （.），（：：），（.*），（？：），（sizeof） 不可使用友元函数重载的有： = 、 （） 、 【】、 -> 对于无法修改左操作数的时候，只能使用全局函数实现。 双目运算符 以“+”运算符为例 //对于两个整型
菜鸟学习历程【28】面向对象编程（2）
leessang_bo的博客
01-12 173
对象初始化列表 类中如果有一个其它类的对象，而其他类没有无参构造函数时，无法初始化该类的对象，此时需要对象的初始化列表。 举个圆类与点类的例子进行说明： class Point { public: Point(int x, int y) { m_x = x; m_y = y; printf("调用了点(%d, %d)的构造函
springboot(酒店管理系统)
最新发布
04-25
开发语言：Java JDK版本：JDK1.8（或11） 服务器：tomcat 数据库：mysql 5.6/5.7（或8.0） 数据库工具：Navicat 开发软件：idea 依赖管理包：Maven 代码+数据库保证完整可用，可提供远程调试并指导运行服务（额外付费）～ 如果对系统的中的某些部分感到不合适可提供修改服务，比如题目、界面、功能等等... 声明： 1.项目已经调试过，完美运行 2.需要远程帮忙部署项目，需要额外付费 3.本项目有演示视频，如果需要观看，请联系我 4.调试过程中可帮忙安装IDEA，eclipse，MySQL，JDK，Tomcat等软件 重点： 需要其他Java源码联系我，更多源码任你选，你想要的源码我都有！ 需要加v19306446185
 c++多态学习例子
09-09
下面是一个简单的多态学习例子： ```python class Animal: def sound(self): pass class Dog(Animal): def sound(self): print("汪汪汪！") class Cat(Animal): def sound(self): print("喵喵喵！") def ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值