C++快速讲解（七）：继承和多态

最新推荐文章于 2023-07-20 21:33:12 发布
最新推荐文章于 2023-07-20 21:33:12 发布
阅读量287 收藏 2
点赞数
分类专栏： C++系列博客 文章标签： C++继承 C++多态
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_32306361/article/details/115124192
版权

C++快速讲解（七）：继承和多态


前言：主要讲解了继承和多态的用法。

1.继承入门

#include <iostream>
#include <string>

using namespace std;

//父类
class Father{
public:
    string name;
    int age;
};

//子类
class Son: public Father{

};

int main() {
    //子类虽然没有声明name 和 age ，但是继承了Father类，等同于自己定义的效果一样
    Son s;
    s.name = "张三";
    s.age = 18;

    cout << s.name << " = " << s.age << endl;
    return 0;
}

在这里插入图片描述

2.public、protected、private继承

  • public：表示公有成员，该成员不仅可以在类内可以被访问，在类外也是可以被访问的，是类对外提供的可访问接口；

  • private：表示私有成员，该成员仅在类内可以被访问，在类的外面无法访问；

  • protected：表示保护成员，保护成员在类的外面同样是隐藏状态，无法访问。但是可以在子类中访问。

3.构造和析构

3.1 继承状态

  • 子类对象在创建时会首先调用父类的构造函数;

  • 父类构造函数执行完毕后,执行子类的构造函数;

  • 当父类的构造函数中有参数时,必须在子类的初始化列表中显示调用;

  • 析构函数执行的顺序是先调用子类的析构函数，再调用父类的析构函数

#include <iostream>
#include <string>
//构造和析构  继承状态
using namespace std;

class Father{
public:
    string name;
    int age;

    Father(){
        cout<<"调用了父类构造"<<endl;
    }

    ~Father(){
        cout<<"调用了父类析构"<<endl;
    }
};

class Son: public Father{
public:
    Son(){
        cout<<"调用了子类构造"<<endl;
    }

    ~Son(){
        cout<<"调用了子类析构"<<endl;
    }
};

int main() {
    Son s;
    return 0;
}

在这里插入图片描述

3.2 继承和组合

  • 先调用父类的构造函数,再调用组合对象的构造函数,最后调用自己的构造函数;
  • 先调用自己的析构函数,再调用组合对象的析构函数,最后调用父类的析构函数。
#include <iostream>
#include <string>
//构造和析构  继承和组合
using namespace std;

class Father{
public:
    string name;
    int age;

    Father(){
        cout<<"调用了父类构造"<<endl;
    }

    ~Father(){
        cout<<"调用了父类析构"<<endl;
    }
};

class Other{
public:
    Other(){
        cout<<"调用了Other构造"<<endl;
    }

    ~Other(){
        cout<<"调用了Other析构"<<endl;
    }
};

class Son: public Father{
public:
    Son(){
        cout<<"调用了子类构造"<<endl;
    }

    ~Son(){
        cout<<"调用了子类析构"<<endl;
    }
    Other o;
};

int main() {
    Son s;
    return 0;
}

在这里插入图片描述

3.3 调用父类有参构造

  • 继承关系下，子类的默认构造函数会隐式调用父类的默认构造函数，假设父类没有默认的无参构造函数，那么子类需要使用参数初始化列表方式手动调用父类有参构造函数。
  • 一般来说在创建子类对象前，就必须完成父类对象的创建工作，也就是在执行子类构造函数之前，必须先执行父类的构造函数。
#include <iostream>
#include <string>
//构造和析构  调用父类有参构造
using namespace std;

class Father{
private:
    string name;
    int age;
public:
    Father(int age,string name){
        cout<<"调用了父类构造"<<endl;
        this->name = name;
        this->age = age;
    }

};


class Son: public Father{

    //子类只能使用初始化列表的方式来访问父类构造
public:
    Son(int age,string name):Father(age,name){
        cout<<"调用了子类构造"<<endl;
    }
};

int main() {
    Son s(20,"fly");
    return 0;
}

在这里插入图片描述

3.4 初始化列表

常量和引用的情况

#include <iostream>
#include <string>
//常量和引用的情况
using namespace std;

class Father{
public:
    const string name;
    int &age;

    Father(string name,int age):name(name),age(age){
        cout<<"调用了构造"<<endl;
    }

};



int main() {
    Father f("fly",20);
    cout << f.name << " = " << f.age << endl;
    return 0;
}

初始化对象成员

#include <iostream>
#include <string>

using namespace std;

class Father{
public:
    int age;
    Father(int age):age(age){
        cout<<"调用了父类构造"<<endl;
    }

};

class Son{

public:
    Father f;
    Son():f(10){
        cout<<"调用了Son类构造"<<endl;
    }
};

int main() {
    Son s;
    cout<<s.f.age<<endl;
    return 0;
}

4.重写父类同名函数

#include <iostream>
#include <string>
//重写父类同名函数
using namespace std;

class Father{
public:

    void smoke(){
        cout<<"抽普通烟"<<endl;
    }

};


class Son: public Father{

public:
    void smoke(){
        Father::smoke();
        cout<<"抽高级烟"<<endl;
    }
};

int main() {
    Son s;
    s.smoke();
    return 0;
}

在这里插入图片描述

5.多重继承

#include <iostream>
#include <string>
//多重继承
using namespace std;

class Father{
public:
    void makeMoeny(){
        cout << "赚钱" << endl;
    }
};
class Mother{
public:
    void makeHomeWork(){
        cout << "做家务活" << endl;
    }
};

class Son:public Father , public Mother{

};

int main(){

    Son s ;
    s.makeMoeny();
    s.makeHomeWork();

    return 0 ;
}

在这里插入图片描述

6.类的前置声明

#include <iostream>
#include <string>
//类的前置声明
using namespace std;

class father; //所有前置声明的类，在某个类中定义的时候，只能定义成引用或者指针。

class son{
public:
    //father f0; //因为这行代码，单独拿出来说，会执行B类的无参构造，
    //但是编译器到此处的时候，还不知道B这个类的构造长什么样。
    father &f1;
    father *f2;

    son(father &f1 , father *f2):f1(f1),f2(f2){

    }
};


class father{

};


int main(){

    //  father b; //---> 执行B的构造函数。
    father f1;
    father f2;

    son s(f1 ,&f2);

    return 0 ;
}

7.多态

7.1 静态多态

静态多态是编译器在编译期间完成的，编译器会根据实参类型来选择调用合适的函数，如果有合适的函数可以调用就调，没有的话就会发出警告或者报错 。

#include <iostream>
#include <string>
//静态多态
using namespace std;

int Add(int m, int n){
    return m+n;
}

double Add(double  m, double  n){
    return m+n;
}

int main() {
    Add(10,20);
    Add(10.2,20.2);
    return 0;
}

7.2 动态多态

它是在程序运行时根据父类的引用（指针）指向的对象来确定自己具体该调用哪一个类的虚函数。

#include <iostream>
#include <string>

using namespace std;


class Father{

public:
    virtual void smoke(){ //加上virtual
        cout << "father smoke" << endl;
    }
};

class Son : public Father{

public:
    void smoke(){
        cout << "son smoke" << endl;
    }
};


int main() {

    Father f;
    f.smoke(); //父亲的抽烟

    Son s ;
    s.smoke(); //孩子的抽烟

    Father *f2 = new Son();//父类指针指向子类对象
    f2->smoke();

    return 0;
}

在这里插入图片描述

8.联编机制

8.1 静态类型和动态类型

  • 静态类型：不需要运行，编译状态下即可知晓具体的类型
  • 动态类型：只有真正运行代码了，才能知晓具体的类型

8.2 父类指针指向子类对象

#include<iostream>

using namespace std;

class father{
public:
    void show(){
        cout << "father show" << endl;
    }
};

class children : public father{
public:
    void show(){
        cout << "children  show" << endl;
    }
};

int main(){
    father f = children();
    f.show(); // 打印father show

    return 0 ;
}

8.3 静态联编和动态联编

#include<iostream>

using namespace std;

class WashMachine{
public:
    void wash(){
        cout << "洗衣机在洗衣服" << endl;
    }
};


class SmartWashMachine : public WashMachine{
public:
    void wash(){
        cout << "智能洗衣机在洗衣服" << endl;

    }

};

int main(){
    WashMachine *w1= new WashMachine(); //父类指针指向父类对象  打印：洗衣机在洗衣服
    w1->wash();

    SmartWashMachine *s  = new SmartWashMachine();  //子类指针指向子类对象 打印： 智能洗衣机...
    s->wash();

    WashMachine *w2 = new SmartWashMachine(); //父类指针指向子类对象 打印..洗衣机在洗衣服
    w2->wash();

    return 0 ;
}

9.虚函数

9.1 虚函数入门

#include <iostream>
#include <string>
//虚函数
using namespace std;

class WashMachine{
public:
    virtual void wash(){
        cout << "洗衣机在洗衣服" << endl;
    }
};

class SmartWashMachine : public WashMachine{
public:
    virtual  void wash(){
        cout << "智能洗衣机在洗衣服" << endl;

    }
};

int main(){

    WashMachine *w2 = new SmartWashMachine(); //父类指针指向子类对象 打印..洗衣机在洗衣服
    w2->wash();
    return 0 ;
}

在这里插入图片描述

9.2 虚函数的工作原理

  • 通常情况下，编译器处理虚函数的方法是： 给每一个对象添加一个隐藏指针成员，它指向一个数组，数组里面存放着对象中所有函数的地址。这个数组称之为虚函数表（virtual function table ） 。表中存储着类对象的虚函数地址。
  • 父类对象包含的指针，指向父类的虚函数表地址，子类对象包含的指针，指向子类的虚函数表地址。
  • 如果子类重新定义了父类的函数，那么函数表中存放的是新的地址，如果子类没有重新定义，那么表中存放的是父类的函数地址。

9.3 构造函数不可以是虚函数

构造函数不能为虚函数 , 因为虚函数的调用，需要虚函数表(指针)，而该指针存在于对象开辟的空间中，而对象的空间开辟依赖构造函数的执行。

9.4 析构函数可以是虚函数

#include <iostream>
#include <string>

using namespace std;

class father{

public:
    virtual ~father(){
        cout << "执行父类析构函数" << endl;
    }
};


class son : public father{
    ~son(){
        cout << "执行子类析构函数" << endl;
    }
};

int main(){

    father *f = new son(); //父类指针指向子类对象

    //创建的是子类对象，理应执行子类的析构函数
    delete f;

    return 0 ;
}

10.override 关键字

#include <iostream>
#include <string>

using namespace std;

class father{
public:
    virtual void run(){
        cout << "父亲在跑步" << endl;
    }
};


class son : public father{
public:
    virtual  void run() override{ //表示重写父类的函数
        cout << "孩子在跑步" << endl;
    }
};

int main(){

    father *f = new son(); //父类指针指向子类对象
    return 0 ;
}

11.final 关键字

#include <iostream>
#include <string>

using namespace std;

class person final{ //表示该类是最终类，无法被继承
    virtual void run() final{ //表示该方法时最终方法，无法被重写

    }
};


//编译错误，无法被继承。
class student : public person{
    //编译错误，方法无法被重写。
    void run(){

    }
};

int main(){
    
    return 0 ;
}

12.=delete 和 =default

#include <iostream>
#include <string>

using namespace std;

class stu{

    string name;
    int age;

public:
    stu(string name , int age):name(name) , age(age){
        cout << "执行stu的构造函数" << endl;
    }
    
    //表示禁止调用拷贝构造函数
    stu(stu & s) =delete;


    ~stu(){
        cout << "执行stu的析构函数" << endl;
    }
};

int main(){

    stu s("张三",18) ;

    //编译错误。
    stu s1= s;

    return 0 ;
}

#include <iostream>
#include <string>

using namespace std;

class stu{

    string name;
    int age;

public:

    stu() = default;

    stu(string name , int age):name(name) , age(age){
        cout << "执行stu的构造函数" << endl;
    }

    ~stu(){
        cout << "执行stu的析构函数" << endl;
    }
};

int main(){

    stu s("张三",18) ;

    //编译错误。
    stu s1 = s;

    return 0 ;
}

13.纯虚函数

#include <iostream>
#include <string>
//纯虚函数
using namespace std;

class WashMachine{
public:
    //没有函数体，表示洗衣机能洗衣服，但是具体怎么洗，每个品牌不一样
    virtual void wash() = 0;
};

class HaierMachine:public WashMachine{
public :
    virtual void wash(){
        cout << "海尔牌洗衣机在洗衣服" << endl;
    }
};

class LittleSwanMachine:public WashMachine{
public :
    virtual void wash(){
        cout << "小天鹅洗衣机在洗衣服" << endl;
    }
};

int main(){

    //WashMachine w;  错误，抽象类无法创建对象
    WashMachine *w1 = new HaierMachine() ;
    WashMachine *w2 = new LittleSwanMachine() ;

    return 0 ;
}

14.抽象类和接口

所谓接口，其实就是用于描述行为和功能，并不会给出具体的实现。C++中没有提供类似interface 这样的关键字来定义接口 ， 纯虚函数往往承担起了这部分功能，可以看成是对子类的一种约束。

例如：

class Person{
      Person() =default; // 可以用于初始化成员函数
      virtual ~Person()=default; //防止子类析构函数无法被调用问题


      //每个人吃什么，做什么都不一样，，即可声明为纯虚函数
      virtual void eat() = 0 ;
      virtual void work() = 0 ;
      //...

};

结束！！！

等待着冬天的风
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
C++多态与继承详解
06-03
C++多态与继承详解PPT资源，图文并茂，详细讲解多态和继承
C++多态
weixin_43186756的博客
03-08 419
什么是多态 定义：在面向对象中，多态是指通过基类的指针或者引用，在运行时动态调用实际绑定对象函数的行为。与之相对应的编译时绑定函数称为静态绑定。 多态是设计模式的基础，多态是框架的基础。 静态多态是编译器在编译期间完成的，编译器会根据实参类型来选择调用合适的函数，如果有合适的函数就调用，没有的话就会发出警告或者报错； 动态多态是在程序运行时根据基类的引用（指针）指向的对象来确定自己具体该调用哪一个类的虚函数。 为什么要引入动态多态 C++中的父子类间的赋值兼容：子类对象可以当作父类对象使用（兼容性）；具体
C++基础：实现多态以及代替多态的方法
WORK_GAME_LINE的博客
03-02 172
多态运用场景以及其他实现的代替多态方法
c++多态，子类和父类方法的调用
qq_38967321的博客
07-28 4023
#include using namespace std; class A{ public:     void run(){         cout     }     virtual void run0(){         cout     }     A(){         cout     }     virtual ~
C++—继承、多态
qq_45042822的博客
05-20 262
继承 类之间的关系 继承：在已有类的基础上创建新类的过程 一个 B 类继承A类，或称从类 A 派生类 B 类 A 称为基类（父类），类 B 称为派生类（子类） 基类和派生类 访问控制 不论种方式继承基类，派生类都不能直接使用基类的私有成员 派生类的生成过程 派生类的生成过程经历了三个步骤： （1）吸收基类成员（全部吸收(构造、析构除外),但不一定可见） ●在C++的继承机制中，派生类吸收基类中除构造函数和析构函数之外的全部成员。 (2) 改造基类成员 ● 通过在派生类中定义同名成员（包括成员函数和数据
【C++】继承与多态
Pursue quality, not quantity.
03-01 1684
C++继承与多态万字详解！！
C++——继承和多态
weixin_57133901的博客
03-07 2185
多态： 多态按字面的意思就是多种形态。当类之间存在层次结构，并且类之间是通过继承关联时，就会用到多态。 C++ 多态意味着调用成员函数时，会根据调用函数的对象的类型来执行不同的函数。 多态性是面向对象程序设计的关键技术之一。若程序设计语言不支持多态性，不能称为面向对象的语言。利用多态性技术，可以调用同一个函数名的函数，实现完全不同的功能。 1.1两种多态： 1.1.1编译时多态（早绑定）： 编译时的多态通过函数的重载和运算符的重载来实现的。 就像是未出生的男女孩定下的娃娃亲。 1.1.2运行时多态（晚绑定）
C++—继承与多态
热门推荐
帅气的羊的博客
05-28 2万+
一、类继承    C++是一种面向对象的语言，最重要的一个目的就是——提供可重用的代码，而类继承就是C++提供来扩展和修改类的方法。类继承就是从已有的类中派生出新的类，派生类继承了基类的特性，同时可以添加自己的特性。...
封装、继承、多态一语道破
10-23
言简意赅的讲解面向对象封装、继承、多态的概念
C++ 多态 虚函数 虚函数表 最是详细
10-01
高质量的C++多态讲解，详细讲解虚函数，虚函数表，虚函数继承，虚函数继承下的内存分配等
现代C++编程：从基础到实战项目全覆盖.docx
最新发布
02-28
面向对象编程篇：详细讲解类和对象的定义、继承、多态和封装等面向对象的核心概念。 高级特性篇：深入探讨模板编程、标准模板库(STL)的使用，以及异常处理、文件操作等高级主题。 实战项目篇： 游戏开发项目：指导...
C++继承,虚函数与多态性专题
04-08
本文分两部分即继承和虚函数与多态性，本文第一部分详细讲解了继承时的构造函数和析构函数的问题，父类与子类的 同名变量和函数问题，最后介绍了多重继承与虚基类。本文第二部分重点介绍了虚函数与多态性的问题，...
【C++】继承和多态
Qiuhan_909的博客
07-20 534
C++继承和多态
C++中的继承与多态
m0_72410588的博客
05-01 254
继承是指一个类从另一个类派生而来，新的类可以继承旧类的属性和方法，并在此基础上进行扩展。在 C++ 中，使用关键字class或struct定义类时可以通过进行继承。// 基类class Shape {public:// 派生类class Rectangle : public Shape {public:多态是指通过基类访问派生类对象的一种机制，包括静态多态和动态多态两种。
C++ 继承和多态
鄭高兴
12-30 849
(1) 继承是C++源生支持的一种语法特性，是C++面向对象的一种表现(2) 继承特性可以让派生类“瞬间”拥有基类的所有（当然还得考虑权限）属性和方法(3) 继承本质上是为了代码复用(4) 类在C++编译器的内部可以理解为结构体，派生类是由基类成员叠加派生类新成员得到的父类的public成员 在子类中是public的父类的protected成员 在子类中是protected的父类的private成员 在子类中是private的，权限进一步降低，只能通过父类的public方法间接访问。
C++继承和多态
weixin_39861267的博客
05-05 2756
继承和多态
[C++] 继承和多态
weixin_51654781的博客
05-31 1175
对C++ 继承和多态较为详细的笔记， 内存布局， 虚表等
C++快速讲解（十）：线程
等待着冬天的风的博客
03-27 5541
前言：主要介绍了线程的创建、join和detach、线程传递参数、获取线程id、结束线程、并发访问、线程同步等。
讲解一些C++类、继承、多态等特性
06-12
C++是一种面向对象编程语言，具有类、继承、多态等特性，下面分别进行讲解： 1. 类：C++中的类是一种用户自定义的数据类型，可以封装数据和行为。类中可以定义成员变量和成员函数，成员变量表示数据，成员函数表示...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

等待着冬天的风

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值