14. C++中继承与多态

最新推荐文章于 2024-07-27 13:52:26 发布
最新推荐文章于 2024-07-27 13:52:26 发布
阅读量359 收藏 3
点赞数
分类专栏： c++ 文章标签： C++继承与多态 纯虚函数 虚函数 函数重载和函数重写的区别
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhubao124/article/details/103103392
版权

如果子类定义了与父类中原型相同的函数会发生什么？在子类中定义与父类中原型相同的函数叫做函数重写。函数重写只发生在父类与子类之间。

#include <cstdlib>
#include <iostream>

using namespace std;

class Parent
{
public:
    void print()
    {
        cout<<"I'm Parent..."<<endl;
    }
};

class Child : public Parent
{
public:
    void print()
    {
        cout<<"I'm Child..."<<endl;
    }
};

int main(int argc, char *argv[])
{
    Child child;
    
    child.print();
    
    child.Parent::print();
    
    cout << "Press the enter key to continue ...";
    cin.get();
    return EXIT_SUCCESS;
}

编译运行结果如下：

1. 父类中被重写的函数依然会继承给子类；
        2. 默认情况下子类中重写的函数将隐藏父类中的函数；
        3. 通过作用域分辨符::可以访问到父类中被隐藏的函数；

当函数重写遇上赋值兼容性原则。你期望下面的程序输出什么？

#include <cstdlib>
#include <iostream>

using namespace std;

class Parent
{
public:
    void print()
    {
        cout<<"I'm Parent..."<<endl;
    }
};

class Child : public Parent
{
public:
    void print()
    {
        cout<<"I'm Child..."<<endl;
    }
};

void howToPrint(Parent* p)
{
    p->print();
}

void run()
{
    Child child;
    Parent* pp = &child;
    Parent& rp = child;
    
    child.print();
    
    pp->print();
    
    rp.print();
}

int main(int argc, char *argv[])
{
    run();
    
    cout << "Press the enter key to continue ...";
    cin.get();
    return EXIT_SUCCESS;
}

编译运行结果如下：

         1. C++与C相同，是静态编译型语言；
         2. 在编译时，编译器自动根据指针的类型判断指向的是一个什么样的对象；
         3. 所以编译器认为父类指针指向的是父类对象（根据赋值兼容性原则，这个假设合理）；
         4. 由于程序没有运行，所以不可能知道父类指针指向的具体是父类对象还是子类对象；
         5. 从程序安全的角度，编译器假设父类指针只指向父类对象，因此编译的结果为调用父类的成员函数；

 

下面函数调用后的输出是什么？

在编译这个函数的时候，编译器不可能知道指针 p 究竟指向了什么。但是编译器没有理由报错。于是，编译器认为最安全的做法是编译到父类的print函数，因为父类和子类肯定都有相同的print函数。

 

面向对象的新需求
               1. 根据实际的对象类型来判断重写函数的调用；
               2. 如果父类指针指向的是父类对象则调用父类中定义的函数；
               3. 如果父类指针指向的是子类对象则调用子类中定义的重写函数；

多态：同样的调用语句有多种不同的表现形态。

 

C++中的多态支持
              C++中通过virtual关键字对多态进行支持，使用virtual声明的函数被重写后即可展现多态特性。

#include <cstdlib>
#include <iostream>

using namespace std;

class Boss
{
private:
    static Boss* cInstance;
    
    Boss()
    {
    }
public:
    static Boss* GetInstance()
    {
        if( cInstance == NULL )
        {
             cInstance = new Boss();
        }
        
        return cInstance;
    }
    
    int fight()
    {
        cout<<"Boss::fight()"<<endl;
        return 10;
    }
};

Boss* Boss::cInstance = NULL;

class Master
{
public:
    virtual int eightSwordKill()
    {
        cout<<"Master::eightSwordKill()"<<endl;
        return 8;
    }
};

class NewMaster : public Master
{
public:
    virtual int eightSwordKill()
    {
        cout<<"NewMaster::eightSwordKill()"<<endl;
        return Master::eightSwordKill() * 2;
    }
};

void fieldPK(Master* master, Boss* boss)
{
    int k = master->eightSwordKill();
    int b = boss->fight();
    
    if( k < b )
    {
        cout<<"Master is killed..."<<endl;
    }
    else
    {
        cout<<"Boss is killed..."<<endl;
    }
}

int main(int argc, char *argv[])
{
    Boss* boss = Boss::GetInstance();
    
    cout<<"Master vs Boss"<<endl;
    
    Master master;
    
    fieldPK(&master, boss);
    
    cout<<"New Master vs Boss"<<endl;
    
    NewMaster newMaster;
    
    fieldPK(&newMaster, boss);
    
    cout << "Press the enter key to continue ...";
    cin.get();
    return EXIT_SUCCESS;
}

编译运行结果如下：

 

重载和重写有什么区别？什么时候是重载，什么时候是重写？那种效率更高？

函数重载
               1. 必须在同一个类中进行；
               2. 子类无法重载父类的函数，父类同名函数将被覆盖；
               3. 重载是在编译期间根据参数类型和个数决定调用函数；
        函数重写
               1. 必须发生于父类与子类之间；
               2. 并且父类与子类中的函数必须有完全相同的原型；
               3. 使用virtual声明之后能够产生多态；
               4. 多态是在运行期间根据具体对象的类型决定调用函数；

注：函数重载效率更高。

#include <cstdlib>
#include <iostream>

using namespace std;

class Parent
{
public:
    virtual void func()
    {
        cout<<"void func()"<<endl;
    }
    
    virtual void func(int i)
    {
        cout<<"void func(int i)"<<endl;
    }
    
    virtual void func(int i, int j)
    {
        cout<<"void func(int i, int j)"<<endl;
    }
};

class Child : public Parent
{
public:
    void func(int i, int j)
    {
        cout<<"void func(int i, int j)"<<" "<<i + j<<endl;
    }
    
    void func(int i, int j, int k)
    {
        cout<<"void func(int i, int j, int k)"<<" "<<i + j + k<<endl;
    }
};

void run(Parent* p)
{
    p->func(1, 2);
}

int main(int argc, char *argv[])
{
    Parent p;
    
    p.func();
    p.func(1);
    p.func(1, 2);
    
    Child c;
    //c.fun();   //Error
    c.func(1, 2);
    
    run(&p);
    run(&c);
    
    cout << "Press the enter key to continue ...";
    cin.get();
    return EXIT_SUCCESS;
}

编译运行结果如下：

 

是否可以将类的每个成员函数都声明为虚函数？

C++中多态的实现原理
              1. 当类中声明虚函数时，编译器会在类中生成一个虚函数表；
              2. 虚函数表是一个存储类成员函数指针的数据结构；
              3. 虚函数表是由编译器自动生成与维护的，并且虚函数表会编译到最终的可执行文件中；
              4. virtual成员函数会被编译器放入虚函数表中；
              5. 存在虚函数时，每个对象中都有一个指向虚函数表的指针；

注：出于效率考虑，没有必要将所有成员函数都声明为虚函数。

 

对象中的VPTR指针什么时候被初始化？

        1. 对象在创建的时候由编译器对VPTR指针进行初始化；
                2. 只有当对象的构造完全结束后VPTR的指向才最终确定；
                3. 父类对象的VPTR指向父类虚函数表；
                4. 子类对象的VPTR指向子类虚函数表；

注：构造函数中调用虚函数无法实现多态。

#include <cstdlib>
#include <iostream>

using namespace std;

class Parent
{
public:
    Parent()
    {
        this->func();
    }
    
    virtual void func()
    {
        cout<<"void Parent::func()"<<endl;
    }
};

class Child : public Parent
{
public: 
    void func()
    {
        cout<<"void Child::func()"<<endl;
    }
};

int main(int argc, char *argv[])
{
    Child c;
    
    cout << "Press the enter key to continue ...";
    cin.get();
    return EXIT_SUCCESS;
}

编译运行结果如下：

执行Child c;创建对象的时候。首先调用父类的构造函数，然后C++编译器对VPTR指针进行初始化，即VPTR  --->  parent::VTABLE；然后构造函数有调用了fun()；C++编译发现fun()是虚函数，然后就到虚函数表中查找，然后就找到了父类中的fun()；所以结果就是我们看到的样子。即构造函数中调用虚函数无法实现多态。

 

纯虚函数

在现实中需要知道具体的图形类型才能求面积，所以对概念上的“图形”求面积是没有意义的！

这个类的设计完全脱离实际，没有任何的意义！

用Shape作为基类进行继承

#include <cstdlib>
#include <iostream>

using namespace std;

class Shape
{
public:
    virtual double area() = 0;
};

class Rectangle : public Shape
{
    double m_a;
    double m_b;
public:
    Rectangle(double a, double b)
    {
        m_a = a;
        m_b = b;
    }
    
    double area()
    {
        return m_a * m_b;
    }
};

class Circle : public Shape
{
    double m_r;
public:
    Circle(double r)
    {
        m_r = r;
    }
    
    double area()
    {
        return 3.14 * m_r * m_r;
    }
};

void area(Shape* s)
{
    cout<<s->area()<<endl;
}

int main(int argc, char *argv[])
{
    Rectangle rect(2, 3);
    Circle circle(4);
    
    area(&rect);
    area(&circle);
    
    cout << "Press the enter key to continue ...";
    cin.get();
    return EXIT_SUCCESS;
}

编译运行结果如下：

面向对象中的抽象类
               1. 抽象类可用于表示现实世界中的抽象概念；
               2. 抽象类是一种只能定义类型，而不能产生对象的类；
               3. 抽象类只能被继承并重写相关函数；
               4. 抽象类的直接特征是纯虚函数；

注：纯虚函数是只声明函数原型，而故意不定义函数体的虚函数。

抽象类与纯虚函数
               1. 抽象类不能用于定义对象；
               2. 抽象类只能用于定义指针和引用；
               3. 抽象中的纯虚函数必须被子类重写；

 

小结：

       1. 函数重载与函数重写不同；
               2. 多态是通过虚函数表实现的；
               3. 虚函数在效率上会受到影响；
               4. 抽象类可用于表示现实世界中的抽象概念；
               5. 抽象类是通过纯虚函数实现的；
 

参考：https://www.runoob.com/w3cnote/cpp-virtual-functions.html

 

 

zhubao124
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
用C语言实现C++ 继承与多态
南风fahaxiki
10-18 493
功能，在调用创建的类函数时就十分不安全，在基类加入基类类型名和类大小成员变量可以解决这个问题。就是当创建一个类时，不需要重新编写新的数据成员和成员函数，只需指定新建的类继承了一个已有的类的成员即可。的方式，即把基类作为派生类的成员变量之一。，即只拷贝了地址，没有拷贝地址的内容。举个例子：人是动物，人具有动物的行为和属性，但人也有动物所不具备的行为和属性。在上个例子中，人和动物都有会动的属性，但人的动作和动物的动作从表现上会有所不同。就可以实现在同一个函数中，根据对象类型的不同，函数实现方式也不同。
C语言模拟实现C++的继承与多态示例
08-30
本篇文章主要介绍了C语言模拟实现C++的继承与多态示例，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
浅谈c++的精髓之继承和多态
09-10
浅谈c++的精髓之继承和多态
C++——继承和多态
weixin_57133901的博客
03-07 2358
多态： 多态按字面的意思就是多种形态。当类之间存在层次结构，并且类之间是通过继承关联时，就会用到多态。 C++ 多态意味着调用成员函数时，会根据调用函数的对象的类型来执行不同的函数。 多态性是面向对象程序设计的关键技术之一。若程序设计语言不支持多态性，不能称为面向对象的语言。利用多态性技术，可以调用同一个函数名的函数，实现完全不同的功能。 1.1两种多态： 1.1.1编译时多态（早绑定）： 编译时的多态通过函数的重载和运算符的重载来实现的。 就像是未出生的男女孩定下的娃娃亲。 1.1.2运行时多态（晚绑定）
C++中的继承与多态_多态
最新发布
2301_79746169的博客
07-27 965
C++中的继承与多态2 1. 多态的概念 1.1 概念 2. 多态的定义及实现 2.1多态的构成条件 ​编辑2.2 虚函数 2.3虚函数的重写 2.4 C++11 override 和 final 2.5 重载、覆盖(重写)、隐藏(重定义)的对比 3. 抽象类 3.1 概念 3.2 接口继承和实现继承 4.多态的原理 4.1虚函数表 4.2多态的原理 4.3 动态绑定与静态绑定 5.单继承和多继承关系的虚函数表 5.1 单继承中的虚函数表 5.2 多继承中的虚函数表 5
C++ 继承和多态
鄭高兴
12-30 1151
(1) 继承是C++源生支持的一种语法特性，是C++面向对象的一种表现(2) 继承特性可以让派生类“瞬间”拥有基类的所有（当然还得考虑权限）属性和方法(3) 继承本质上是为了代码复用(4) 类在C++编译器的内部可以理解为结构体，派生类是由基类成员叠加派生类新成员得到的父类的public成员 在子类中是public的父类的protected成员 在子类中是protected的父类的private成员 在子类中是private的，权限进一步降低，只能通过父类的public方法间接访问。
【C++】继承与多态
Pursue quality, not quantity.
03-01 1903
C++继承与多态万字详解！！
CPP.rar_多态 .cpp_继承与多态_继承与多态C++
09-23
标题中的"CPP.rar_多态 .cpp_继承与多态_继承与多态C++"表明这个压缩包文件包含了关于C++编程语言中多态性（Polymorphism）和继承（Inheritance）的概念示例。多态性和继承是面向对象编程（Object-Oriented ...
C++中的封装、继承、多态理解
12-20
总的来说，封装、继承和多态是C++中实现面向对象编程的关键工具，它们协同工作，使得代码更加灵活、可扩展且易于维护。通过封装，我们可以隐藏实现细节，提高安全性；通过继承，我们可以复用代码，构建层次化的类...
C++程序设计课件：4 继承与多态.ppt
09-21
C++程序设计课件：4 继承与多态 本节课程主要讲解了C++编程语言中的继承和多态性相关知识，涉及到继承的概念、继承类型、继承体现的思想、基类和派生类的关系、单继承、多继承、纯虚函数和抽象类等。 继承是面向...
C++继承和多态
weixin_39861267的博客
05-05 2901
继承和多态
C++继承与多态
m0_62656812的博客
12-16 548
C++是一款面向对象的语言，对象是可以物化的实体，拥有自己的特性与行为，像车子有外形，内核，可以加速减速。而车子又分为保时捷与宝马、奔驰等等。我们想要描述一个车子对象的特征，就需要创建一个类，若为每一种车创建一个类，会使效率下降，而不同车子之间既有共性又有特性，因此，便产生了派生类。 一、派生类的继承方式 派生类（子类）继承了基类（父类）的特性，同时它可以添加自己的诸多特点。继承的方式有以下三种 既：派生类对基类的继承小于等于基类的数据（包括成员变量与成员函数） 无论...
【C++】继承和多态
like_that的博客
05-01 948
一、继承 继承是使代码复用的一种机制。（本质） 单继承：一个派生类一个基类派生。 多继承：一个派生类有两个人或者多个基类。（如：马与驴杂交所生的骡子就有两个基类，骡子既继承了马的一些特征，也继承了驴的一些特征） 派生类 构造派生类包括： 1、从基类接收成员；（派生类接收基类的全部成员，没有选择） 2、调整从基类接收的成员；（可以改变基类成员在派生类中的访问属性（通过继承的...
C++ ——继承和多态
Li27的博客
08-20 683
继承&多态两大特性的初步实现机制；抓住对实体的抽象，多层抽象，定义出丰富的类！
C++ 继承&多态
weixin_33906657的博客
03-19 82
继承&多态· 访问限定符*继承访问控制的作用是将继承下来的成员在派生类域内的属性改变而和原本基类的成员访问控制符关。所有的基类private成员在派生类里是不可见，但它确确实实被继承下来了。基类的protected成员只对继承它的派生类可见，在类外不可使用· 派生类列表 在定义派生类的时候我们必须写出派生类列表，但在声明处不可写。1.虚函数的使用（多态的实现）#...
C++ 继承与多态
XXXTENTAC1ON的博客
03-23 2385
继承与多态介绍继承的概念与定义 介绍 继承机制 是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员保持原有类特性的基础上进行扩展，增加功能；这样产生新的类，称派生类；继承呈现了面向对象程序设计的层次结构；体现了由简单到复杂的认识过程 多态性 是考虑在不同层次的类中，以及在统一类中，统么的成员函数之间的关系问题。函数的重载，运算符的重载，属于编译时的多态性；以虚基类为基础的运行时的多态性是面向对象程序设计的标志性特征；体现了类推和比喻的思想方法 早期绑定：编译时就确定了调用关系 晚绑定：程序运行的过
c++继承与多态
转行笔记
08-30 1092
c++继承与多态
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值