C++面向对象三大特性之一：多态（超详细讲解）

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

目录
        多态的概念
        多态的定义及实现
        重载、覆盖(重写)、隐藏(重定义)的对比
        抽象类
        多态的实现原理
        单继承和多继承关系的虚函数表

多态的概念

通俗来说，就是多种形态，具体点就是去完成某个行为，当不同的对象去完成时会产生出不同的状态。即同一事物，在不同场景下表现出不同的状态。
举个栗子：比如买票这个行为，当普通人买票时，是全价买票；学生买票时，是半价买票；军人买票时是优先买票。
再举个栗子： 最近为了争夺在线支付市场，支付宝年底经常会做诱人的扫红包-支付-给奖励金的活动。那么大家想想为什么有人扫的红包又大又新鲜8块、10块…，而有人扫的红包都是1毛，5毛…。其实这背后也是一个多态行为。支付宝首先会分析你的账户数据，比如你是新用户、比如你没有经常支付宝支付等等，那么你需要被鼓励使用支付宝，那么就你扫码金额 = random()%99；比如你经常使用支付宝支付或者支付宝账户中常年没钱，那么就不需要太鼓励你去使用支付宝，那么就你扫码金额 = random()%1；总结一下：同样是扫码动作，不同的用户扫得到的不一样的红包，这也是一种多态行为。ps：支付宝红包问题纯属瞎编，大家仅供娱乐。

多态的定义及实现

多态是在不同继承关系的类对象，去调用同一函数，产生了不同的行为。比如Student继承了Person。Person对象买票全价，Student对象买票半价。
多态的构成条件

  1. 必须通过基类的指针或者引用调用虚函数
  2. 被调用的函数必须是虚函数，且派生类必须对基类的虚函数进行重写

满足多态：跟调用对象的类型无关，跟指向对象有关，指向哪个对象就调用它的虚函数
不满足多态：跟调用对象的类型有关， 类型是什么调用的就是谁的虚函数
在这里插入图片描述
虚函数：即被virtual修饰的类成员函数称为虚函数。

    virtual void BuyTicket()
    { 
        cout << "Person::买票-全价" << endl;
    }

虚函数的重写

  1. 一定是派生类重写基类的虚函数（一个在基类中，一个在派生类中）
  2. 派生类虚函数的原型必须与基类中虚函数的原型（返回值类型、函数名字、参数列表）完全相同
  3. 基类和派生类虚函数的访问权限可以不同；一般将基类的虚函数设置为 public（如果是private，则基类的指针调用不了它的虚函数）
  4. 如果基类是虚函数，派生类中的virtual可以不写，但是我们一般都会写上。
  5. 重写是为了重写函数的实现
#include <iostream>
using namespace std;

class Person
{
public:
    virtual void BuyTicket()
    { 
        cout << "Person::买票-全价" << endl;
    }
};

class Student : public Person
{
public:
    virtual void BuyTicket()
    { 
        cout << "Student::买票-半价" << endl; 
    }
};

void Func(Person& p)
{
    p.BuyTicket();
}

int main()
{
    Person ps;
    Student st;

    Func(ps);
    Func(st);
    return 0;
}

在这里插入图片描述
虚函数重写的两个例外：
1.协变：基类与派生类虚函数返回值类型不同（即基类虚函数返回“基类”对象的指针或者引用，派生类虚函数返回“派生类”对象的指针或者引用）。该基类和派生类可以是其它任意类的基类和派生类。

class A {};
class B : public A {};

class Person
{
public:
    virtual A* Fun1()
    { 
        return new A; 
    }

    virtual Person* Fun2()
    {
        return nullptr;
    }
};

class Student : public Person
{
public:
    virtual B* Fun1() 
    { 
        return new B; 
    }

    virtual Student* Fun2()
    {
        return nullptr;
    }
};

2.析构函数的重写：基类与派生类析构函数的名字不同

  • 基类中的析构函数只要是虚函数，派生类的析构函数定义之后就重写了基类的析构函数。
  • 虽然函数名不相同，看起来违背了重写的规则，其实不然，这里可以理解为编译器对析构函数的名称做了特殊处理，编译后析构函数的名称统一处理成destructor。
#include <iostream>
using namespace std;

class Person
{
public:
    virtual ~Person()
    { 
        cout << "~Person()" << endl; 
    }
};

class Student : public Person
{
public:
    virtual ~Student()
    { 
        cout << "~Student()" << endl;
    }
};

int main()
{
    Person* p1 = new Person;
    Person* p2 = new Student;
    delete p1;
    delete p2;
    return 0;
}

在这里插入图片描述
C++11 override 和 final关键字
从上面可以看出，C++对函数重写的要求比较严格，但是有些情况下由于疏忽，可能会导致函数名字母次序写反而无法构成重载，而这种错误在编译期间是不会报出的，只有在程序运行时没有得到预期结果才来debug会得不偿失，因此：C++11提供了override和final两个关键字，可以帮助用户检测是否重写。

  1. final：修饰虚函数，表示该虚函数不能再被继承
class Car
{
public:
    virtual void Drive() final 
    {}
};

class Benz :public Car
{
public:
    virtual void Drive() 
    { 
        cout << "Benz-舒适" << endl; 
    }
};

在这里插入图片描述
2. override: 检查派生类虚函数是否重写了基类某个虚函数，如果没有重写编译报错。

class Car
{
public:
    virtual void Drive()
    {}
};

class Benz :public Car
{
public:
    virtual void Drive() override
    { 
        cout << "Benz-舒适" << endl; 
    }
};

重载、覆盖(重写)、隐藏(重定义)的对比

在这里插入图片描述

抽象类

在虚函数的后面写上 = 0 ，则这个函数为纯虚函数。包含纯虚函数的类叫做抽象类（也叫接口类），抽象类不能实例化出对象。派生类继承后也不能实例化出对象，只有重写纯虚函数，派生类才能实例化出对象。纯虚函数规范了派生类必须重写，另外纯虚函数更体现出了接口继承。

#include <iostream>
using namespace std;

class Car
{
public:
    virtual void Drive() = 0;
};

class Benz :public Car
{
public:
    virtual void Drive()
    {
        cout << "Benz-舒适" << endl;
    }
};

class BMW :public Car
{
public:
    virtual void Drive()
    {
        cout << "BMW-操控" << endl;
    }
};

void Test()
{
    Car* pBenz = new Benz;
    pBenz->Drive();

    Car* pBMW = new BMW;
    pBMW->Drive();
}

int main()
{
    Test();
    return 0;
}

在这里插入图片描述
接口继承和实现继承
实现继承：普通函数的继承是一种实现继承，派生类继承了基类函数，可以使用函数，继承的是函数的实现。
接口继承：虚函数的继承是一种接口继承，派生类继承的是基类虚函数的接口，目的是为了重写，达成多态，继承的是接口。所以如果不实现多态，不要把函数定义成虚函数。

多态的实现原理

虚函数表
首先我们来看一个问题：sizeof(Base)是多少？

#include <iostream>
using namespace std;

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

    virtual void Func2()
    {
        cout << "Func2()" << endl;
    }
private:
    int _b = 1;
};

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

在这里插入图片描述
很多人会被误导成4，但是看结果其实是8，原因呢？
在对象Base::b中，除了有成员_b，还有一个虚函数表指针，它指向虚函数表，虚函数表中存储着每个虚函数的空间地址。
在这里插入图片描述
在这里插入图片描述
针对上面的代码我们做出以下改造

  1. 我们增加一个派生类Derive去继承Base
  2. Derive中重写Func1
  3. Base再增加一个虚函数Func2和一个普通函数Func3
#include <iostream>
using namespace std;

class Base
{
public:
    virtual void Func1()
    {
        cout << "Base::Func1()" << endl;
    }
    virtual void Func2()
    {
        cout << "Base::Func2()" << endl;
    }
    void Func3()
    {
        cout << "Base::Func3()" << endl;
    }
private:
    int _b = 1;
};

class Derive : public Base
{
public:
    virtual void Func1()
    {
        cout << "Derive::Func1()" << endl;
    }
private:
    int _d = 2;
};

int main()
{
    Base b;
    Derive d;
    return 0;
}

在这里插入图片描述
通过观察对象的内存模型和测试，我们发现了以下几点问题：

  • 基类b对象和派生类d对象虚表是不一样的，这里我们发现Func1完成了重写，所以d的虚表中[0]存的是重写的Derive::Func1的空间地址。同样Func2也被继承下来了，但是Func2没有重写，则d的虚表中[1]存的是Base::Func2的空间地址。Fun3不是虚函数，所以不会放进虚表中。
  • 虚函数的重写也叫作覆盖，覆盖就是指虚表中虚函数的覆盖。重写是语法的叫法，覆盖是原理层的叫法。
  • 虚函数表本质是一个存虚函数指针的指针数组，这个数组最后面放了一个nullptr。
  • 总结一下派生类的虚表生成：a.先将基类中的虚表内容拷贝一份到派生类虚表中 b.如果派生类重写了基类中某个虚函数，用派生类自己的虚函数覆盖虚表中基类的虚函数 c.派生类自己新增加的虚函数按其在派生类中的声明次序增加到派生类虚表的最后。

小问题：虚函数存在哪的？虚表存在哪的？

  • 虚函数和虚表都存在代码段（常量区）
  • 虚表存的是虚函数指针，不是虚函数，虚函数和普通函数一样的，都是存在代码段的，只是他的指针又存到了虚表中。
  • 对象中存的不是虚表，存的是虚表指针。

多态的原理
Func函数传到Person调用的Person::BuyTicket，传Student调用的是Student::BuyTicket在这里插入图片描述

#include <iostream>
using namespace std;

class Person
{
public:
    virtual void BuyTicket()
    { 
        cout << "Person::买票-全价" << endl;
    }
};

class Student : public Person
{
public:
    virtual void BuyTicket()
    { 
        cout << "Student::买票-半价" << endl; 
    }
};

void Func(Person& p)
{
    p.BuyTicket();
}

int main()
{
    Person Mike;    
    Func(Mike);

    Student Johnson;
    Func(Johnson);
    return 0;
}

依据上面的代码我们来分析对象的内存模型：
在这里插入图片描述
在这里插入图片描述

  • p是指向Mike对象时，p->BuyTicket在mike的虚表中找到虚函数是Person::BuyTicket。
  • p是指向Johnson对象时，p->BuyTicket在johson的虚表中找到虚函数是Student::BuyTicket。
  • 在内存中，对象的虚表指针和成员变量都存在于栈上，而虚函数存在于代码段，多态的实现就是通过栈上的虚表指针从代码段中找到虚表的空间地址，再从虚表中找到虚函数在代码段中的空间地址完成调用。
  • 这样就实现出了不同对象去完成同一行为时，展现出不同的形态。
  • 再通过下面的汇编代码分析，看出满足多态以后的函数调用，不是在编译时确定的，是运行起来以后到对象的虚函数表中去找虚函数的空间地址。不满足多态的函数调用时编译时确认好的。

在这里插入图片描述
动态绑定与静态绑定

  1. 静态绑定又称为前期绑定(早绑定)，在程序编译期间确定了程序的行为，也称为静态多态，比如：函数重载。
  2. 动态绑定又称后期绑定(晚绑定)，是在程序运行期间，根据具体拿到的类型确定程序的具体行为，调用具体的函数，也称为动态多态。

单继承和多继承关系的虚函数表

单继承中的虚函数表
我们用一段代码来测试：

#include <iostream>
using namespace std;

class Base
{
public:
    virtual void func1() { cout << "Base::func1" << endl; }
    virtual void func2() { cout << "Base::func2" << endl; }
private:
    int _a;
};

class Derive :public Base
{
public:
    virtual void func1() { cout << "Derive::func1" << endl; }
    virtual void func3() { cout << "Derive::func3" << endl; }
    virtual void func4() { cout << "Derive::func4" << endl; }
private:
    int _b;
};

int main()
{
    Base b;
    Derive d;
    return 0;
}

在这里插入图片描述
可以发现监视窗口给出的结果并不是我们想要的，派生类中自己新添加的虚函数并没有显示，这个时候需要我们想办法去打印虚函数表。

#include <iostream>
using namespace std;

class Base
{
public:
    virtual void func1() { cout << "Base::func1" << endl; }
    virtual void func2() { cout << "Base::func2" << endl; }
private:
    int _a;
};

class Derive :public Base
{
public:
    virtual void func1() { cout << "Derive::func1" << endl; }
    virtual void func3() { cout << "Derive::func3" << endl; }
    virtual void func4() { cout << "Derive::func4" << endl; }
private:
    int _b;
};

//函数指针重定义
typedef void(*VFT_PTR)();

void PrintVFTable(VFT_PTR vftable[])
{
    for (size_t i = 0; vftable[i] != 0; ++i)
    {
        cout << "VFT_PTR:[" << i << "]:" << vftable[i] << "->";
        VFT_PTR f = vftable[i];
        f();
    }
    cout << endl;
}

int main()
{
    Base b;
    //取对象中前四个字节存的虚表指针
    PrintVFTable((VFT_PTR*)(*(int*)&b));

    Derive d;
    PrintVFTable((VFT_PTR*)(*(int*)&d));
    return 0;
}

在这里插入图片描述
从结果中可以看到，派生类的虚表中从上向下依次存储的是重写的Derive::func1、未重写从基类中继承的Base::func2、派生类自己新增加的虚函数Derive::func3和Derive::func4。
在这里插入图片描述
多继承中的虚函数表
我们用一段代码来测试：

#include <iostream>
using namespace std;

class Base1
{
public:
    virtual void func1() { cout << "Base1::func1" << endl; }
    virtual void func2() { cout << "Base1::func2" << endl; }
private:
    int b1;
};

class Base2
{
public:
    virtual void func1() { cout << "Base2::func1" << endl; }
    virtual void func2() { cout << "Base2::func2" << endl; }
private:
    int b2;
}; 

class Derive : public Base1, public Base2
{
public:
    virtual void func1() { cout << "Derive::func1" << endl; }
    virtual void func3() { cout << "Derive::func3" << endl; }
private:
    int d1;
};

int main()
{
    Derive d;
    return 0;
}

在这里插入图片描述
同样可以发现监视窗口给出的结果并不是我们想要的，派生类中自己新添加的虚函数并没有显示，这个时候我们还是去打印它的虚函数表。

#include <iostream>
using namespace std;

class Base1
{
public:
    virtual void func1() { cout << "Base1::func1" << endl; }
    virtual void func2() { cout << "Base1::func2" << endl; }
private:
    int b1;
};

class Base2
{
public:
    virtual void func1() { cout << "Base2::func1" << endl; }
    virtual void func2() { cout << "Base2::func2" << endl; }
private:
    int b2;
}; 

class Derive : public Base1, public Base2
{
public:
    virtual void func1() { cout << "Derive::func1" << endl; }
    virtual void func3() { cout << "Derive::func3" << endl; }
private:
    int d1;
};

//函数指针重定义
typedef void(*VFT_PTR)();

void PrintVFTable(VFT_PTR vftable[])
{
    for (size_t i = 0; vftable[i] != 0; ++i)
    {
        cout << "VFT_PTR:[" << i << "]:" << vftable[i] << "->";
        VFT_PTR f = vftable[i];
        f();
    }
    cout << endl;
}

int main()
{
    Derive d;
    PrintVFTable((VFT_PTR*)(*(int*)&d));
    PrintVFTable((VFT_PTR*)(*(int*)((char*)&d + sizeof(Base1))));
    PrintVFTable((VFT_PTR*)(*(int*)((char*)&d + sizeof(Base2))));
    return 0;
}

如下结果给出了对象d中Base1和Base2的虚表存储
在这里插入图片描述
可以观察到派生类中自己新增加的虚函数存储在Base1的虚表中。
在这里插入图片描述
我们还可以得到对象d在内存中占了20字节大小。
在这里插入图片描述
小问题：

  1. inline函数可以是虚函数吗？
    不能，因为inline函数没有地址，无法把地址放到虚函数表中。
  2. 静态成员可以是虚函数吗？
    不能，因为静态成员函数没有this指针，使用类型::成员函数的调用方式无法访问虚函数表，所以静态成员函数无法放进虚函数表。
  3. 构造函数可以是虚函数吗？
    不能，因为对象中的虚函数表指针是在构造函数初始化列表阶段才初始化的。
  4. 析构函数可以是虚函数吗？什么场景下析构函数是虚函数？
    可以，并且最好把基类的析构函数定义成虚函数。
  5. 对象访问普通函数快还是虚函数更快？
    首先如果是普通对象，是一样快的。如果是指针对象或者是引用对象，则调用的普通函数快，因为构成多态，运行时调用虚函数需要到虚函数表中去查找。
  6. 虚函数表是在什么阶段生成的，存在哪的？
    虚函数是在编译阶段生成的，一般情况下存在代码段（常量区）。
  7. 抽象类的作用？
    抽象类强制重写了虚函数，另外抽象类体现出了接口继承关系。
一杆梅子酒丶
关注
  • 1
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
面向对象三大特性的意义讲解
08-26
面向对象编程是现代软件开发中广泛采用的一种编程范式，其核心特性包括封装、继承和多态。这些特性赋予了程序更高的灵活性、可维护性和可扩展性。 首先，我们来看看封装。封装是面向对象编程的基础，它将数据和操作...
面向对象三大特性之多态
weixin_48565202的博客
04-12 1521
typora-copy-images-to: ./ 多态 什么是多态？ 多态就是函数调用的多种形态，使用多态能够使得不同对象去完成同一件事，产生不同的动作和结果。 例如，在现实生活中普通人买票是全价，学生买票是半价，而军人允许有先买票。不同身份的人去买票，产生的行为是不同的，这就是都多态。 多态的分类 在C++中，多态的实现和**联编（也称绑定）**这一概念有关。一个源程序经过编译、链接，成为可执行文件的过程是把可执行代码联编（或称装配）在一起的过程。其中在运行之前就完成的联编成为静态联编（前期联编）.
多态实现及原理刨析
qq_52145272的博客
08-29 810
系列文章目录 【C++从入门到入土】第一篇：从C到C++. 【C++从入门到入土】第二篇：类和对象基础. 【C++从入门到入土】第三篇：类和对象提高. 【C++从入门到入土】第四篇：运算符重载. 【C++从入门到入土】第五篇：继承（爆肝画图详解）. 文章目录系列文章目录前言一、 多态的基本概念二、怎么实现动态多态三、动态多态的原理四、纯虚函数和抽象类五、虚析构和纯虚析构总结 前言 提示：这里可以添加本文要记录的大概内容： 例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学
C++面向对象三大特性之---多态
最新发布
m0_74910646的博客
05-07 844
多态是在不同继承关系的类对象，去调用同一函数，产生了不同的行为。比如Student继承了 Person。Person对象买票全价，Student对象买票半价。必须通过基类的指针或者引用调用虚函数被调用的函数必须是虚函数，且派生类必须对基类的虚函数进行重写在虚函数的后面写上=0，则这个函数为纯虚函数。包含纯虚函数的类叫做抽象类（也叫接口类），抽象类不能实例化出对象。派生类继承后也不能实例化出对象，只有重写纯虚函数，派生类才能实例化出对象。
C++面向对象特性——多态
CLZHIT的博客
12-27 744
多态性（ polymorphism ）是面向对象设计语言的基本特征之一。仅仅是将数据和函数捆绑在一起，进行类的封装，使用一些简单的继承，还不能算是真正应用了面向对象的设计思想。多态性是面向对象的精髓。多态性可以简单地概括为“一个接口，多种方法”。通常是指对于同一个消息、同一种调用，在不同的场合，不同的情况下，执行不同的行为。虚函数就是在基类中被声明为virtual，并在一个或多个派生类中被重新定义的成员函数。// 类内部 class 类名 {virtual 返回类型 函数名(参数表) {
C++面向对象 多态
zy1872071381的博客
08-25 666
C++面向对象 多态
c++类和对象之多态
weixin_62688907的博客
07-24 517
多态是在不同继承关系的类对象，去调用同一函数产生了不同的行为。必须通过基类的指针或者引用去调用虚函数被调用的函数必须是虚函数，且派生类必须对基类的虚函数进行重写！public买票-全价100￥"...
面向对象三大特性_面向对象_
09-28
面向对象的三大特性是封装、继承和多态，它们是理解OOP的关键。 **封装** 是面向对象的基础，它意味着将数据（属性）和操作这些数据的方法（函数）绑定在同一个单元——对象中。这样可以隐藏对象内部的实现细节，只...
C++面向对象多线程编程-pdf
09-12
在"C++面向对象多线程编程"这一主题中，我们将深入探讨以下几个关键知识点： 1. 面向对象编程（OOP）基础： - 类与对象：类是对象的蓝图，定义了一组属性（数据成员）和行为（成员函数）。对象是类的实例，具有...
C++面向对象方法课程设计报告案例ATM柜员机程序共27页
10-29
总的来说，这份27页的C++面向对象方法课程设计报告将详细讲解如何利用面向对象编程技巧来设计和实现一个实用的ATM柜员机程序。通过这个案例，学生不仅可以学习到C++的基础语法，还能深入理解面向对象设计原则和最佳...
C++解析(23)：多态与C++对象模型
weixin_30924239的博客
12-08 152
0.目录 1.多态 2.C++对象模型 2.1 使用C语言实现封装 3.继承对象模型 4.多态对象模型 4.1 使用C语言实现多态 5.小结 1.多态 面向对象中期望的行为： 根据实际的对象类型判断如何调用重写函数 父类指针（引用）指向 父类对象则调用父类中定义的函数 子类对象则调用子类中定义的重写函数 面向对象中的多态的概念： 根据实际的对象类型决定函数调用的具体目标 同样的调...
C++面向对象三大特性-多态
weixin_48344647的博客
04-15 164
介绍了C++中多态的特性，抽象类（接口类）的定义方法和说明，多态的底层原理。
【C++】13.多态
szh0331的博客
03-18 268
必须通过基类的指针或者引用调用虚函数被调用的函数必须是虚函数，且派生类必须对基类的虚函数进行重写重载:1.两个函数在同一作用域2.函数名相同 参数不同重写:1.两个函数分别在父类和子类的作用域2.函数名/参数/返回值都必须相同(协变例外)3.两个函数都必须是虚函数重定义(隐藏)1.两个函数分别在父类和子类的作用域2.函数名相同3.两个父类和子类的同名函数不构成重写就是重定义。
C++面向对象的三大特性----多态
ftzchina的博客
11-20 782
一文帮你理解和掌握C++的多态
多态详细讲解
wanggang182007的博客
12-09 410
1.多态是方法的多态，属性没有多态 2.父类和子类有联系，类型转换异常！classcastexception 3.存在条件，继承关系，方法需要重写，父类引用指向子类对象Father f1=new Son（）； 4.不能继承的有 （1）static方法，属于类，不属于实例 （2）final常量 （3）private方法 5.定义：同一方法根据发送对象的不同采用不同的行为方式（都是run（）方法，不同对象调用结果不一样） 一个对象的类型是确定的，可以指向对象的引用类型有很多（父类，有关系的类）
基础篇——面向对象及多态性详解
一个灵活的胖子MrWang
04-24 4156
写代码的四点： 1.明确需求。要做什么？ 2.分析思路。要怎么做？（1,2,3……） 3.确定步骤。每一个思路要用到哪些语句、方法和对象。 4.代码实现。用具体的语言代码将思路实现出来。学习新技术的四点： 1.该技术是什么？ 2.该技术有什么特点？（使用需注意的方面） 3.该技术怎么使用？（写Demo） 4.该技术什么时候用？（在Pr...
C/C ：面向对象的三大特性 —— 封装、继承、多态
weixin_41565755的博客
05-02 1296
一、面向对象的三大特性 1、封装 通过封装将一部分成员隐藏起来，另一部分成员作为类或对象与外部的接口。从而控制数据的访问权限，并且能够减少程序中不同部分之间的相互影响。隐藏对象的属性和接口实现细节，仅仅对外提供接口和方法。 优点：提高安全性，隔离影响。 2、继承 在父类基础上创建派生类，可以通过增加、修改、替换父类成员产生派生类，对父类进行...
面向对象三大特征（封装、继承、多态）详解
qq_45976767的博客
04-06 4440
面向对象的三大特征 万物皆可归类，类是对于世界事物的高度抽象，不同的事物有不同的关系：一个类自身与外界的封装关系；一个父类与子类的继承关系；一个类和多个类的多态关系。 万物皆对象，对象是具体的世界事物，面向对象的三大特征：封装、继承、多态，封装说明一个行为和属性与其他的类的关系，继承是父类和子类的关系，多态是类与类之前的关系 封装 概念 封装就是把抽象的数据（属性）和对数据的操作（方法）封装在一起，数据被保护在内部，程序的其他部分只有通过被授权的操作，才能对数据进行操作 理解和好处 1、封装隐藏了实
多态的详解
m0_53677355的博客
09-06 432
在代码编译时，编译器无法知道基类的引用到底引用哪个类的对象，因此编译时无法确定要调用哪个类的方法，只有等到程序运行起来之后，才知道应该调用哪个类的方法。① 构造方法不能被重写：构造方法特殊，构造方法作用在调用对象时，由编译器调用，将对象中的成员初始化完整，只有对象真正创建好之后，才可以用其调用其他的方法实现多态，而对象真正创建好之后，构造方法已经调用完了 ，不可能再在构造方法上实现多态。例外：协变：被重写的方法返回值类型可以不同，返回值有要求：基类方法返回基类的引用，子类方法返回子类的引用。
C++面向对象：多态与虚函数详解
本章小结主要关注C++面向对象程序设计中的关键概念——多态性。多态性是面向对象编程的重要特性，它允许在运行时根据对象的实际类型来调用相应的函数，从而提高代码的灵活性和可扩展性。具体来说，本章涉及两种多态...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值