55 - 经典问题解析四（动态内存分配 & 虚函数 & 继承中的强制类型转换）

已于 2023-11-28 21:00:41 修改
阅读量428 收藏
点赞数
分类专栏： C++ 深度解析教程 文章标签： c++ 开发语言
于 2022-11-28 17:56:23 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_36098975/article/details/128079641
版权

---- 整理自狄泰软件唐佐林老师课程

文章目录

1. 关于动态内存分配

  • new 和 malloc 的区别是什么？
  • delete 和 free 的区别又是什么？

1.1 问题一：new 和 malloc 的区别

1.1.1 new 关键字和 malloc 函数的区别

new 关键字是 C++ 的一部分malloc 是由 C 库函数提供的函数
new 以具体 类型 为单位进行内存分配malloc 以 字节 为单位进行内存分配
new 在申请内存空间时可进行初始化malloc 仅根据需要申请定量的内存空间
new 在所有 C++ 编译器都被支持malloc 在某些系统开发中是不能调用的
new 能够触发构造函数的调用malloc 仅分配需要的内存空间
对象的创建只能使用 newmalloc 不适合面向对象开发

1.1.2 编程实验：new 和 malloc 的区别一

  • 下面的代码输出什么？为什么？

在这里插入图片描述

#include <iostream>
#include <string>

using namespace std;

class Test
{
public:
	Test() {
		cout << "Test()" << endl;
	}
};

int main()
{
	Test* pn = new Test;
	Test* pm = (Test*)malloc(sizeof(Test));
    return 0;
}

在这里插入图片描述

1.1.3 编程实验：new 和 malloc 的区别二

  • 下面的代码输出什么？为什么？

在这里插入图片描述

#include <iostream>
#include <string>

using namespace std;

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

int main()
{
	Test* pn = new Test;
	Test* pm = (Test*)malloc(sizeof(Test));
	
	delete pn;
	free(pm);
	
    return 0;
}

在这里插入图片描述

1.2 问题二：delete 和 free 的区别

delete 在所有 C++ 编译器中都被支持free 在某些系统开发中是不能调用的
delete 能够触发析构函数的调用free 仅归还之前分配的内存空间
对象的销毁只能使用 deletefree 不适合面向对象开发

2. 关于虚函数

2.1 问题一

  • 构造函数是否可以成为虚函数？
  • 析构函数是否可以成为虚函数？
  • 构造函数 不可能 成为虚函数
    • 在构造函数执行结束后，虚函数表指针才会被正确的初始化
  • 析构函数 可以 成为虚函数
    • 建议在设计类时将析构函数声明为虚函数

- 编程实验：构造、析构、虚函数

#include <iostream>
#include <string>

using namespace std;

class Base
{
public:
    virtual Base() {}
    ~Base() {}
};

class Derived : public Base
{
public:
    Derived() {}
    ~Derived() {}
};

int main()
{   
    return 0;
}

在这里插入图片描述

#include <iostream>
#include <string>

using namespace std;

class Base
{
public:
    Base() {
		cout << "Base()" << endl;
	}
    ~Base() { // 未将析构函数声明为 virtual
			  // 于是，编译器直接将 p 当作 Base*
		cout << "~Base()" << endl;
	}
};

class Derived : public Base
{
public:
    Derived() {
		cout << "Derived()" << endl;
	}
    ~Derived() {
		cout << "~Derived()" << endl;
	}
};

int main()
{
	Base* p = new Derived();
        
    delete p; // 期望是打印两个析构函数中的输出
	
    return 0;
}

在这里插入图片描述

#include <iostream>
#include <string>

using namespace std;

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

class Derived : public Base
{
public:
    Derived() {
		cout << "Derived()" << endl;
	}
    ~Derived() {
		cout << "~Derived()" << endl;
	}
};

int main()
{
	Base* p = new Derived();
        
    delete p;
	
    return 0;
}

在这里插入图片描述

2.2 问题二

  • 构造函数中是否可以发生多态？
  • 析构函数中是否可以发生多态？
  • 构造函数中 不可能 发生多态行为
    • 在构造函数执行时，虚函数表指针 未被 正确初始化
  • 析构函数中 不可能 发生多态行为
    • 在析构函数执行时，虚函数表指针 已经被销毁
  • 构造函数和析构函数中调用虚函数不可能发生多态行为，只调用 当前类中 定义的函数版本
#include <iostream>
#include <string>

using namespace std;

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

class Derived : public Base
{
public:
    Derived() {
		cout << "Derived()" << endl;
		func();
	}
	virtual void func() {
		cout << "Derived::func()" << endl;
	}
    ~Derived() {
		cout << "~Derived()" << endl;
		func();
	}
};

int main()
{
	Base* p = new Derived();
        
    delete p;
	
    return 0;
}

在这里插入图片描述

3. 关于继承中的强制类型转换 dynamic_cast

  • 继承中如何正确的使用强制类型转换？
  • dynamic_cast 是与继承相关的类型转换关键字
  • dynamic_cast 要求相关的类中必须有虚函数
  • 用于 直接或者间接继承关系的指针（引用） 之间
    • 指针：
      转换成功：得到目标类型的指针
      转换失败：得到一个 空指针
    • 引用：
      转换成功：得到目标类型的引用
      转换失败：得到一个 异常操作信息
  • 编译器会检查 dynamic_cast 的使用是否正确
  • 类型转换的结果只可能在 运行阶段 才能得到

- 编程实验：dynamic_cast的使用

#include <iostream>
#include <string>

using namespace std;

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

class Derived : public Base
{

};

int main()
{
	Base* p = new Base;
	Derived* pd = dynamic_cast<Derived*>(p);

    if (pd != NULL) {
		cout << "pd = " << pd << endl;
	} else {
		cout << "Cast error!" << endl;
	}
	
	delete p;
	
    return 0;
}

在这里插入图片描述

  • 注解：
#include <iostream>
using namespace std;

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

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

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

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

int main(){
    A* pA;
    B* pB;
    C* pC;
    D* pD = new D;
    
    pA = dynamic_cast<A*>(pD);  //向上转型成功

    if (pA == NULL){
        cout<<"Upcasting failed: D* to A*"<<endl;
    } else {
        cout<<"Upcasting successfully: D* to A*"<<endl;
    }

    pB = dynamic_cast<B*>(pD);  //向上转型成功

    if (pB == NULL){
        cout<<"Upcasting failed: D* to B*"<<endl;
    } else {
        cout<<"Upcasting successfully: D* to B*"<<endl;
    }

    pC = dynamic_cast<C*>(pD);  //向上转型成功

    if (pC == NULL){
        cout<<"Upcasting failed: D* to C*"<<endl;
    } else {
        cout<<"Upcasting successfully: D* to C*"<<endl;
    }
    
    cout << endl;
    delete pD;
   
    return 0;
}

在这里插入图片描述

#include <iostream>
using namespace std;

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

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

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

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

int main(){
    A* pA = new A;
    B* pB;
    C* pC;
    D* pD;

    pB = dynamic_cast<B*>(pA);  //向下转型失败

    if (pB == NULL){
        cout<<"Downcasting failed: A* to B*"<<endl;
    } else {
        cout<<"Downcasting successfully: A* to B*"<<endl;
    }

    pC = dynamic_cast<C*>(pA);  //向下转型失败

    if (pC == NULL){
        cout<<"Downcasting failed: A* to C*"<<endl;
    } else {
        cout<<"Downcasting successfully: A* to C*"<<endl;
    }

    pD = dynamic_cast<D*>(pA);  //向下转型失败

    if (pD == NULL){
        cout<<"Downcasting failed: A* to D*"<<endl;
    } else {
        cout<<"Downcasting successfully: A* to D*"<<endl;
    }

    cout << endl;
    delete pA;
   
    return 0;
}

在这里插入图片描述

参考引用自：http://c.biancheng.net/view/2343.html

  • 上述代码中，类的继承顺序是 class D：class C：class B：class A，
    • 当pA是指向A类型的对象时（ pA = new A; ），向下转型失败，pA不能转换为B*、C*、D*类型。
    • 当pD是指向D类型的对象时（ pD = new D; ），向上转型成功，pD可以转换为A*、B*、D*类型。
    • 原因：因为每个类都会在内存中保存一份类型信息，编译器会将存在继承关系的类的类型信息使用指针“连接”起来，从而形成一个继承链，如下所示。
        当使用 dynamic_cast 对指针进行类型转换时，程序会先找到该指针指向的对象，再根据对象找到当前类（指针指向的对象所属的类）的类型信息，并从此节点开始沿着继承链向上遍历，如果找到了要转化的目标类型，那么说明这种转换是安全的，就能够转换成功，如果没有找到要转换的目标类型，那么说明这种转换存在较大的风险，就不能转换。
      在这里插入图片描述
  • 补充：
    • dynamic_cast 用于在类的继承层次之间进行类型转换，它既允许向上转型（Upcasting），也允许向下转型（Downcasting）。向上转型是无条件的，不会进行任何检测，所以都能成功；向下转型的前提必须是安全的，要借助 RTTI 进行检测，所有只有一部分能成功。
    • dynamic_cast 与 static_cast 是相对的，dynamic_cast 是“动态转换”的意思，static_cast 是“静态转换”的意思。dynamic_cast 会在程序运行期间借助 RTTI 进行类型转换，这就要求基类必须包含虚函数；static_cast 在编译期间完成类型转换，能够更加及时地发现错误。
      • 向上转型时，只要待转换的两个类型之间存在继承关系，并且基类包含了虚函数（这些信息在编译期间就能确定），就一定能转换成功。因为向上转型始终是安全的，所以 dynamic_cast 不会进行任何运行期间的检查，这个时候的 dynamic_cast 和 static_cast 就没有什么区别了。
      • 向下转型是有风险的，dynamic_cast 会借助 RTTI 信息进行检测，确定安全的才能转换成功，否则就转换失败。
    • RTTI代表运行时类型信息，它提供了运行时确定对象类型的方法。

4. 小结

  • new / delete会触发构造函数或者析构函数的调用
  • 构造函数不能成为虚函数
  • 析构函数可以成为虚函数
  • 构造函数和析构函数中都无法产生多态行为
  • dynamic_cast是与继承相关的专用关键字
uuxiang
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
模拟技术中的C&D最新14位A/D转换器满足工业环境要求
12-03
C&D Technologies在其双采样A/D转换器产品中增加了ADSD-1420S和ADS-1420EX系列。功能完整的14-Bit模块提供20MSPS采样率及超出工作温度范围无误码。    ADSD-1420S为商业级应用设计，工作温度范围0℃ - +70℃。...
电源技术中的C&D推出应用于中间总线结构（IBA）的1/4砖转换器
11-28
生产并销售电力转换和储备系统的科技公司C&D Technologies，为计算机和通信设备中的中间总线电源结构应用推出新款成本低、体积小的隔离DC/DC转换器——QUS40-096。该转换器为非稳压输出，输入输出电压转换率为固定的...
继承-强制类型转换
weixin_33919950的博客
09-10 206
为什么80%的码农都做不了架构师？>>> ...
关于继承中的强制类型转换
weixin_44550629的博客
12-02 83
dynamic_cast是与继承相关的类型转换关键字dynamic_cast要求相关的类中必须有虚函数用于直接或者间接继承关系的指针(引用)之间-指针： 　　转换成功：得到目标类型的指针 　　转换失败：得到一个空指针-引用： 　　转换成功：得到目标类型的引用 　　转换失败：得到一个异常操作信息 编译器会检查dynamic_cast的使用是否正确类型转换的结果只可能在运行阶段才能得到 #incl...
类继承和强制类型转换
maikeerdai的专栏
07-03 757
在C语言里  不同类型之间的赋值 如果不是强制类型转换，编译的时候就会有警告发生； 在C++语言里  不同类型之间的赋值 如果不是强制类型转换，编译的时候就会有错误发生， 但是有一种情况是基类和派生类之间的类型如果不一样，编译时候可以不发生错误，比如   class  node{         int a; }; class  datanode:public node{     
父类与子类的继承，多态与强制转换
fzw159753的博客
04-17 548
继承的特点： Java的继承通过extends关键字实现。 实现继承的类被称为子类。 被继承的类称为父类。 public class Fruit { public double weight; public void info() { System.out.println("我是一个水果! 重:" + weight + "g!"); } } pub...
继承（2）类的强制类型转换 instanceof
allower的博客
10-07 115
import java.util.*; import java.time.*; class Employee{ private String name; private double salary; private LocalDate hireday; public Employee(String name,double salary,int year,int month,int day) { this.name=name;
55套-各行业响应式网站模板-适配移动端-HTML源码(毕设&课设&大作业可用).zip
最新发布
04-11
此外，这些模板还考虑了用户体验和交互设计，利用Ajax和jQuery实现了丰富的动态效果和无缝的页面转换，提升了网站的互动性和用户参与度。对于追求效率的程序员来说，这些模板提供了代码复制即用的便捷性，极大地缩短...
Eval-SQL.NET：SQL Eval函数使用C＃语法在SQL Server中动态评估表达式
01-28
向您SQL Server提供所有缺少的部分，例如正则表达式和动态算术字符串评估。 -- SELECT 3 SELECT SQLNET::New( ' x+y ' ).ValueInt( ' x ' , 1 ).ValueInt( ' y ' , 2 ).EvalInt() as Result 查找您的解决方案： ...
mql5_chinese.rar_MQL5 函数_MQL5中文手册_MQl5—chinese_famousw55_mql5
07-15
《MQL5中文手册——深度解析与应用指南》 MQL5是一种强大的编程语言，专为MetaTrader 5交易平台设计，用于开发交易机器人、技术指标和脚本。本手册是针对MQL5函数的详尽参考资料，对于在金融交易领域进行自动化交易...
动态分配内存之new
wbainngg123的专栏
08-31 733
动态分配内存之new   首先：为什么需要动态定义数组呢？   这是因为，很多情况下，在预编译过程阶段，数组的长度是不能预先知道的，必须在程序运行时动态的给出   但是问题是，c++要求定义数组时，必须明确给定数组的大小，要不然编译通不过      如： int Array[5];正确        int i=5;        int Array[i]; 错误 因为
【C++】动态内存分配（含图文详解）：new / delete、new[] / delete[]、operator new / operator delete、定位 new
m0_67470729的博客
04-11 1015
C 和 C++ 的内存管理一篇通！！new 和 malloc 整个系列详细讲解，图文并茂哦~
c++特有的动态分配内存new操作符
weiwang1996的博客
03-25 653
在C语言中我们使用malloc()、calloc()、realloc()库函数来动态分配内存，当然也适用于C++，但在C++中有更好的方法———new运算符。
C与C++（提高）动态内存分配——new(delete)与malloc(free)辨析—超详解
m0_74045201的博客
10-25 742
动态创建变量（数组）时即是在堆区进行创建，我们知道，C++中通过new关键字动态开辟空间，使用delete释放；C语言中通过malloc关键字在动态开辟空间，使用free释放.它们之间有何区别，结合自己所学知识并参考了许多博主的文章，讨论C++与C中的动态内存分配区别做出总结。
35.c++动态内存分配new delete
weixin_63779802的博客
05-29 693
今天进行了新的学习。在之前我们已经学过了c语言的动态内存分配，你是否还记得呢？首先就让我们来回顾一下c语言是如何进行动态内存分配的。
C++的new动态分配
little_startoo的博客
05-15 1011
C++的new动态分配
C++动态内存管理：new 和 delete
小青菜的博客
01-27 1879
C++ new 和 delete
动态分配内存——new/delete
mantou_riji的博客
03-18 3097
动态分配内存1.使用new分配内存2.使用delete释放内存 1.使用new分配内存 使用格式： new 数据类型 new 经常和指针一起使用，指针真正的用武之地就是在运行阶段指向未命名的内存以存储值。 eg：在运行阶段为一个int值分配未命名的内存 //通过指针来访问未命名内存的值 int * ptr_int =new int; 解释：ptr_int 的 内存 2.使用delete释放内存 和new配对使用 //释放new分配的内存 delete ptr_int; ...
C++ 动态内存分配入门之一new的用法
我的博客
10-01 681
C++ 动态内存分配入门之一new的用法
AO8810&14-VB：2个N沟道TSSOP8封装MOSFET特性与应用解析
- **温度范围**：工作结温（TJ）和存储温度范围从-55°C至150°C，满足各种环境条件下的可靠运行。 - **热阻**： - 热阻（RthJA）表示结温与环境之间的热交换，典型值为72°C/W，最高值为83°C/W，保证了良好的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

uuxiang

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

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

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

打赏作者

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

抵扣说明：

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

余额充值