慕课网-C++远征之多态篇（下）-学习笔记

最新推荐文章于 2024-09-19 13:36:34 发布
最新推荐文章于 2024-09-19 13:36:34 发布
阅读量107 收藏
点赞数
文章标签： c/c++
原文链接：https://yq.aliyun.com/articles/631019
版权

RTTI（运行时类型识别）

Run-Time Type Identification

  • typeid < - > dynamic_cast

例子：

class Flyable
{
public:
    virtual void takeoff() = 0;//起飞
    virtual void land() = 0; //降落
};

class Bird:public Flyable
{
public:
    void foraging(){}
    virtual void takeoff(){}
    virtual void land(){}
private:
    //...
};

class Plane:public Flyable
{
public:
    void carry(){}
    virtual void takeoff(){}
    virtual void land(){}
};

使用时：

void doSomething(Flyable *obj)
{
    obj ->takeoff();
    //如果是bird，则觅食
    //如果是plane，则运输
    obj -> land();
}

如果对指针能进行判断。然后根据传入指针不同调用不同方法。

void doSomething(Flyable *obj)
{
    obj ->takeoff();
    cout << typeid(*obj).name() <<endl;
    if(typeid(*obj) == typeid(Bird))
    {
        Bird *bird = dynamic_cast<Bird *>(obj);
        //尖括号内是我们想要转化成的类型。
        bird -> foraging();
    }
    obj -> land();
}

总结:

dynamic_cast注意事项：

  • 只能应用于指针和引用的转换
  • 要转换的类型中必须包含虚函数
  • 转换成功返回子类的地址，失败返回NULL

typeid注意事项：

  • type_id返回一个type_info对象的引用
  • 如果想通过基类的指针获得派生类的数据类型，基类必须带有虚函数
  • 只能获取对象的实际类型.(不能判断当前指针)
type_info

name() & 运算符重载

RTTI代码示例
要求 
#ifndef FLYABLE_H
#define FLYABLE_H
class Flyable
{
public:
    virtual void takeoff() = 0;//起飞
    virtual void land() = 0; //降落
};
#endif

#ifndef PLANE_H
#define PLANE_H

#include <string>
#include "Flyable.h"
using namespace std;

class Plane :public Flyable
{
public:
    void carry();
    virtual void takeoff();
    virtual void land();
};


#endif


#include <iostream>
#include "Plane.h"
using namespace std;

void Plane::carry()
{
    cout << "Plane::carry()" << endl;
}
void Plane::takeoff()
{
    cout << "Plane::takeoff()" << endl;
}
void Plane::land()
{
    cout << "Plane::land()" << endl;
}


#ifndef BIRD_H
#define BIRD_H
#include "Flyable.h"
#include <string>
using namespace std;
class Bird :public Flyable
{
public:
    void foraging();
    virtual void takeoff();
    virtual void land();
};

#endif // !BIRD_H

#include <iostream>
#include "Bird.h"
using namespace std;

void Bird::foraging()
{
    cout << "Bird::foraging()" << endl;
}
void Bird::takeoff()
{
    cout << " Bird::takeoff()" << endl;
}
void Bird::land()
{
    cout << "  Bird::land()" << endl;
}

main.cpp1:

#include <iostream>
#include "Bird.h"
#include "Plane.h"
using namespace std;
#include <stdlib.h>

void doSomething(Flyable *obj)
{
    cout << typeid(*obj).name() << endl;
    obj->takeoff();
    if (typeid(*obj) == typeid(Bird))
    {
        Bird *bird = dynamic_cast<Bird *>(obj);
            bird->foraging();
    }
    if (typeid(*obj) == typeid(Plane))
    {
        Plane *plane = dynamic_cast<Plane *>(obj);
        plane->carry();
    }

    obj->land();
}

int main()
{
    Bird b;
    doSomething(&b);

    system("pause");
    return 0;
}

运行结果：

运行结果
  • 传入的是bird。所以执行了bird分支下的觅食。
  • 当传入是plane时。执行carry。
plane-carry
代码说明typeid .dynamic_cast注意事项
int main()
{
    int i =0;
    cout <<typeid(i).name() << endl; 
}

输出为int。打印出数据类型。

int main()
{
    Flyable *p = new Bird();
    cout << typeid(p).name() << endl;
    cout << typeid(*p).name() << endl;
    system("pause");
    return 0;
}
p类型为Flyable *,*p类型为bird对象

将Flyable.h的两个纯虚函数改为普通的。

#ifndef FLYABLE_H
#define FLYABLE_H
class Flyable
{
public:
    void takeoff(){ };//起飞
    void land() {}; //降落
};
#endif

bird.h虚函数去掉。

#ifndef BIRD_H
#define BIRD_H
#include "Flyable.h"
#include <string>
using namespace std;
class Bird :public Flyable
{
public:
    void foraging();
    void takeoff();
    void land();
};

#endif // !BIRD_H

bird 和flyable变成普通的继承。

int main()
{
   // Flyable *p = new Bird();
   // Bird *b = dynamic_cast<Bird *>p;
   // //“dynamic_cast”:“Flyable”不是多态类型
   // 
   
   system("pause");
   return 0;
}

对于dynamic_cast.转换类型还是被转类型都要求有虚函数。

int main()
{
    Flyable p;
    Bird b = dynamic_cast<Bird>p;
    //“dynamic_cast”:“Flyable”不是多态类型

    system("pause");
    return 0;
  • 只能应用于指针和引用的转换
练习题
  • 继承关系不是RTTI的充分条件，只是必要条件，所以存在继承关系的类不一定可以用RTTI技术
  • RTTI的含义是运行时类型识别
  • RTTI技术可以通过父类指针识别其所指向对象的真实数据类型
  • 运行时类型别必须建立在虚函数的基础上，否则无需RTTI技术
巩固练习

定义一个能够移动（Movable）类，要求含有纯虚函数move
定义一个公交车（Bus）类，继承Movable类，并实现函数move，定义函数carry
定义一个坦克（Tank）类，继承Movable类，并实现函数move，定义函数shot。
定义函数doSomething（Movable *obj）,根据s指向对象的类型调用相应的函数。

实例化公交车类和坦克类，将对象传入到doSomething函数中，调用相应函数

#include <iostream>
#include <stdlib.h>
#include <string>
#include <typeinfo>
using namespace std;

/**
 * 定义移动类：Movable
 * 纯虚函数：move
 */
class Movable
{
public:
    virtual void move() = 0;
};

/**
 * 定义公交车类：Bus
 * 公有继承移动类
 * 特有方法carry
 */
class Bus : public Movable
{
public:
    virtual void move()
    {
        cout << "Bus -- move" << endl;
    }
    
    void carry()
    {
        cout << "Bus -- carry" << endl;
    }
};

/**
 * 定义坦克类：Tank
 * 公有继承移动类
 * 特有方法fire
 */
class Tank :public Movable
{
public:
    virtual void move()
    {
        cout << "Tank -- move" << endl;
    }

    void fire()
    {
        cout << "Tank -- fire" << endl;
    }
};

/**
 * 定义函数doSomething含参数
 * 使用dynamic_cast转换类型
 */
void doSomething(Movable *obj)
{
    obj->move();

    if(typeid(*obj) == typeid(Bus))
    {
        Bus *bus = dynamic_cast<Bus *>(obj);
        bus->carry();
    }

    if(typeid(*obj) == typeid(Tank))
    {
        Tank *tank = dynamic_cast<Tank *>(obj);
        tank->fire();
    }
}

int main(void)
{
    Bus b;
    Tank t;
    doSomething(&b);
    doSomething(&t);
    return 0;
}

运行结果：

运行结果
异常处理
  • 异常：程序运行期出现的错误。
  • 异常处理：对有可能发生异常的地方做预见性的安排

网线- 内存不足。

关键字：

  • try...catch... :尝试 捕获
  • throw 抛出异常

思想：

主逻辑(try)与异常处理逻辑(catch)分开

异常处理

三个函数f1,f2,f3.用f2调用f1，f3调用f2.
当f1出现异常会往上抛。如果f2可以处理就可以处理完成。
如果不能处理，会继续进行异常的传播。f3捕获并处理。

void fun1()
{
    throw 1;
}

int main(){
    try {
        fun1();
    }catch(int)//throw的是1，所以用int捕获
    {
        //.....
    }
    return 0;
}

try{
    fun1();
}
catch(int)
{}
catch(double)
{}
catch)(...)//捕获所有的异常
{}

一个try可以有多个catch。不同异常做不同处理。

  • 抛出值，捕获数据类型。
  • 下面我们来做捕获值。
char getChar(const string& aStr,const int aIndex)
{
    if (aIndex > aStr.size())
    {
        throw string("ivalid index!");
    }
    return aStr[aIndex];
}

string str("hello world");
cahr ch;
try{
    ch = getChar(str,100);//这句抛异常，下句不会运行
    cout << ch << endl;
}catch(string& aval){
    cout << aval << endl;
}

常见的异常：

  • 数组下标越界
  • 除数为0
  • 内存不足

异常处理与多态的关系：

异常处理&多态

定义一个接口exception。多个子类来继承该类。那么我们可以通过父类对象捕获不同子类对象的异常。

void fun1()
{
    throw new SizeErr();
}

void fun2()
{
    throw new MemoryErr();
}

try{
    fun1();
}catch(Exception &e)
{
    e.xxx();
}

try{
    fun2();
}catch(Exception &e)
{
    e.xxx();
}

通过父类的引用，调用相应的子类处理函数。

异常处理代码示例
要求 
#include <iostream>
#include <stdlib.h>
#include "IndexException.h"
using namespace std;
void test()
{
    throw 0.1;
}
int main(void)
{
    try
    {
        test();
    }
    catch (double)
    {
        cout << "exception" << endl;
    }
    system("pause");
    return 0;
}
  • 1 对应 int
  • 1.0 对应 double
catch (double &e)
    {
        cout << e << endl;
    }

可以打印出抛出来的异常值：如0.1

#ifndef EXCEPTION_H
#define EXCEPTION_H
class Exception
{
public:
    virtual void printException();
    virtual ~Exception() {};


};
#endif 


#include "Exception.h"
#include <iostream>
using namespace std;

void Exception::printException()
{
    cout << " Exception::printException()" << endl;
}


#ifndef INDEX_EXCEPTION_H
#define INDEX_EXCEPTION_H

#include "Exception.h"
class IndexException:public Exception
{
public:
    virtual void printException();

};
#endif


#include "IndexException.h"
#include <iostream>
using namespace std;

void IndexException::printException()
{
    cout << "提示：下标越界" << endl;
}


#include <iostream>
#include <stdlib.h>
#include "IndexException.h"
using namespace std;
void test()
{
    throw IndexException();
}
int main(void)
{
    try
    {
        test();
    }
    catch (IndexException &e)
    {
        e.printException();
    }
    system("pause");
    return 0;
}

运行结果：

运行结果 
int main(void)
{
    try
    {
        test();
    }
    catch (Exception &e)
    {
        e.printException();
    }
    system("pause");
    return 0;
}

依然打印出数组的提示。父类的引用可以使用到子类的处理函数。

int main(void)
{
    try
    {
        test();
    }
    catch (...)
    {
        cout << "error" << endl;
    }
    system("pause");
    return 0;
}

通过...可以捕获到所有异常。

练习题

  • 在C++中异常处理通常使用try...catch...语法结构。
  • 一个try语句可以对应一个或多个catch语句，但不能没有catch语句
  • C++中使用throw抛出异常，通过catch捕获异常
巩固练习

函数division的两个参数为dividend（被除数）和divisor（除数）
要求用户输入除数和被除数，并作为参数传递给division函数
如果除数为0，则抛出异常，并被捕获，将异常的内容显示到屏幕上

#include <iostream>
#include <string>
#include <stdlib.h>
using namespace std;

/**
 * 定义函数division
 * 参数整型dividend、整型divisor
 */
int division(int dividend, int divisor)
{
    if(0 == divisor)
    {
        // 抛出异常，字符串“除数不能为0”
        throw string("除数不能为0");
    }
    else
    {
        return dividend / divisor;
    }
}

int main(void)
{
    int d1 = 0;
    int d2 = 0;
    int r = 0;
    cin >> d1;
    cin >> d2;
    // 使用try...catch...捕获异常
    try{
        r = division(d1,d2);
        cout << r << endl;
    }catch(string &str){
        cout << str <<endl;
    }

    return 0;
}

运行结果：

除数不能为0.

weixin_34018169
关注
week1_汉诺塔问题/C语言
weixin_46433080的博客
03-14 265
问题描述 　　汉诺塔是一个古老的数学问题： 　　有三根杆子A，B，C。A杆上有N个(N>1)穿孔圆盘，盘的尺寸由下到上依次变小。要求按下列规则将所有圆盘移至C杆： 　　每次只能移动一个圆盘； 　　大盘不能叠在小盘上面。 　　提示：可将圆盘临时置于B杆，也可将从A杆移出的圆盘重新移回A杆，但都必须遵循上述两条规则。 问：如何移？最少要移动多少次？ 输入格式 　　一行，包含2个正整数，一个是N（N<=15)，表示要移动的盘子数；一个是M，表示在最少移动d第M步 输出格式 　　共2行。 　　第一行输出
试题 算法提高 整商问题
qq_47991812的博客
08-06 281
问题描述 　　提示用户输入被除数（dividend）和除数（divisor），若除数为0，则提示用户重新输入，直至除数非零为止。最后输出商。程序建议大家将被除数、除数和商都定义为整形。 　　输入被除数提示语句为：Please enter the dividend: 　　输入除数提示语句为：Please enter the divisor: 　　提示除数为0需要重新输入的语句为： Error: divisor can not be zero! Please enter a new divisor: 　　建议
c++远征之多态篇——异常处理
主要记录嵌入式学习与开发过程。
06-16 596
以下内容源于慕课网的学习整理，如有侵权，请告知删除。 1、关于异常的一些概念 异常：程序运行期出现的错误。 数组下标越界；除数为0；内存不足；…… 异常处理：对有可能发生异常的地方做出预见性的安排。 异常处理使用的关键字 try {   这下面的代码是主体逻辑  }   catch{  这下面的代码异常处理 }throw xxx 抛出异常，其中xxx可以是数
给定两个整数，被除数 dividend 和除数 divisor。将两数相除，要求不使用乘法、除法和 mod 运算符。
ccmedu的博客
10-06 3680
给定两个整数，被除数dividend和除数divisor。将两数相除，要求不使用乘法、除法和 mod 运算符。 返回被除数dividend除以除数divisor得到的商。 示例1: 输入: dividend = 10, divisor = 3 输出: 3 示例2: 输入: dividend = 7, divisor = -3 输出: -2 说明: 被除数和除数均为 3...
c++异常处理
CjhLoveAndroid的博客
03-25 388
异常处理 常见的异常：                   数组下标越界、除数为0、内存不足 下面看一个除数为0的异常处理的例子： /**************************************************************************************/ 函数division的两个参数为dividend（被除数）和di
慕课网-C++远征之多态篇（上）-学习笔记
weixin_34387468的博客
08-30 157
C++远征之多态篇 面向对象三大特征：封装，继承，多态 多态：发出一条命令时，不同的对象接收到同样的命令做出的动作不同 目录： 普通虚函数 & 虚析构函数 纯虚函数：抽象类 & 接口类 RTTI（运行时类型识别） 异常处理 概念：隐藏 & 覆盖 | 早绑定与晚绑定 虚函数表 多...
C++-05继承和多态
03-11
C++继承和多态的学习笔记
C++程序设计-封装、继承多态应用示例
05-09
在C++编程语言中，封装、继承和多态是面向对象编程（OOP）的三大核心概念。这些特性使得C++能够构建出高效、模块化的软件系统。下面将详细解释这三个概念及其在“C++程序设计-封装、继承多态应用示例”中的体现。 1...
Java ------ 多态作业
04-15
Java ------ 多态作业
头歌之学习-Java继承和多态之接口.rar
07-09
里面的内容为： 第1关：学习-Java继承和多态之接口
9-5：C++多态之多态和继承的经典题目以及面试中常考内容
快乐江湖的博客
05-11 631
文章目录一：多态的理解及实现（1）对于多态的理解（2）多态的实现A：实现条件B：虚函数的重写C：虚函数的重写两个例外 一：多态的理解及实现 （1）对于多态的理解 所谓多态，就是指完成某个行为时，不同对象有有不同的完成方法 比如经典的买票行为，学生和普通人都属于人，但是学生买票可以半价，而普通人则只能全票 （2）多态的实现 A：实现条件 用下面的代码为例讲解如何实现多态 #include <iostream> using namespace std; class Person { publi
python中除法运算符是平均成绩不让用除_Leetcode练习(Python)：数学类：第29题：两数相除：给定两个整数，被除数 dividend 和除数 divisor。将两数相除，要求不使用乘法...
weixin_33359523的博客
02-09 241
题目：两数相除：给定两个整数，被除数 dividend 和除数 divisor。将两数相除，要求不使用乘法、除法和 mod 运算符。 返回被除数 dividend 除以除数 divisor 得到的商。整数除法的结果应当截去(truncate)其小数部分，例如：truncate(8.345) = 8以及truncate(-2.7335) = -2提示：被除数和除数均为 32 位有符号整数。除数...
[C/C++]多态
胖胖的ALEX
10-12 893
虚函数 练习题： 定义一个动物（animal）类，要求含有虚函数eat和move，并定义构造函数和虚析构函数 定义一个狗（Dog）类，要求共有继承动物类，定义构造函数和虚析构函数，并实现自己的eat和move函数 使用父类对象实例化子类，调用子类成员函数 #include #include #include using namespace std; /** * 定义动
C++设计模式
叫好与叫座虽然不是对立面，但想在同一个作品中达到双重效果很难。
09-15 1879
Abstract Factory 抽象工厂模式：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。Adapter适配器模式：将一个类的接口转换成客户希望的另外一个接口。Adapter模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工 作。Bridge桥接模式：将抽象部分与它的实现部分分离，使它们都可以独立地变 化。Builder建造者模式：将一个复杂对象的构建与它的表示分离，使得同样的构建 过程可以创建不同的表示。
【C++11 —— 异常】
jokr_的博客
09-17 1292
实际使用中很多公司都会自定义自己的异常体系进行规范的异常管理，因为一个项目中如果大家随意抛异常，那么外层的调用者基本就没办法玩了，所以实际中都会定义一套继承的规范体系。这样大家抛出的都是继承的派生类对象，捕获一个基类就可以了。在软件开发中，尤其是复杂系统的开发中，使用自定义异常体系可以帮助团队规范化异常管理。通过定义一套继承体系，所有抛出的异常都是特定基类的派生类，这样外层调用者可以通过捕获基类来处理所有相关的异常。使用自定义异常可以提供更具体的错误信息，使得代码的可读性和可维护性得到提升。
深度学习实战电路板缺陷检测【数据集+YOLOv5模型+源码+PyQt5界面】
weixin_40280870的博客
09-16 1639
深度学习电路板缺陷检测，模型采用YOLOV5作为框架，界面采用PyQt5构建，图像源支持图像、视频、摄像头以及RTSP等主流格式，电路板缺陷数据集一共690张图象左右，包含六种缺陷，missing_hole【缺失孔】, mouse_bite【鼠咬】, open_circuit【开路】, short【短路】, spur【杂散】, spurious_copper【杂铜】
TMS Scripter Crack TMS Scripter is a Delphi C++ Builder
最新发布
q2315702359的博客
09-19 939
　　The integrated development environment or the IDE allows the users in process of creating script jobs during the runtime with the help of multiple cross-language scripts such as de Pascal and the Basics.　　It has support for the cross-utilization of the s
高精度加法和减法
buaichifanqie的博客
09-18 1152
在C/C++中，我们经常会碰到限定数据范围的情况，我们先来看看常用的int和long long两种数据类型的范围吧。C++标准规定：int占一个机器字长。在32位系统中int占32位，即4个字节，所以int的范围是[-2的31次方，2的31次方-1]，为1e8数量级；longlong的范围则是[-2的63次方，2的63次方-1]，为1e18数量级。如果超过该数量级，该怎么办?此时就需要用到高精度算法。
无规矩不成方圆 - C/C++ 多态
05-23
在 C++ 中，多态是面向对象编程的一种重要概念。它允许我们使用基类的指针或引用来调用派生类的方法，从而实现动态绑定的效果。C++ 中的多态主要分为两种：静态多态和动态多态。 静态多态是指函数重载，它是在编译时确定的。当函数被调用时，编译器会根据参数类型来选择相应的函数。例如： ``` void foo(int x) { cout << "foo(int)" << endl; } void foo(double x) { cout << "foo(double)" << endl; } int main() { foo(10); // 输出 foo(int) foo(3.14); // 输出 foo(double) } ``` 动态多态是指虚函数的实现，它是在运行时确定的。当使用基类的指针或引用来调用虚函数时，会根据指针或引用所指向的实际对象类型来选择相应的函数。例如： ``` class Shape { public: virtual void draw() { cout << "Shape::draw()" << endl; } }; class Circle : public Shape { public: void draw() { cout << "Circle::draw()" << endl; } }; int main() { Shape* pShape = new Circle(); pShape->draw(); // 输出 Circle::draw() } ``` 在上面的例子中，`Shape` 类有一个虚函数 `draw()`，而 `Circle` 类重写了 `draw()` 函数。当我们使用 `Shape` 类的指针 `pShape` 来调用 `draw()` 函数时，实际上调用的是 `Circle` 类的 `draw()` 函数，这就是动态多态的实现。 总的来说，多态在面向对象编程中非常重要，它可以让我们写出更加灵活、可扩展的代码。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值