55-经典问题解析四

最新推荐文章于 2022-11-15 17:42:27 发布
最新推荐文章于 2022-11-15 17:42:27 发布
阅读量164 收藏
点赞数
分类专栏： # C++基础
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/piaoguo60/article/details/108551363
版权

注：博客中内容主要来自《狄泰软件学院》，博客仅当私人笔记使用。

测试环境：Ubuntu 10.10

GCC版本：9.2.0

 

一、关于动态内存分配

                new和malloc的区别是什么？

                delete和free的区别是什么？

 

1）new关键字与malloc函数的区别（表象）

    -    new关键字是C++的一部分

    -    malloc是由C库提供的函数

    -    new以具体类型为单位进行内存分配

    -    malloc以字节为单位进行内存分配

    -    new在申请内存空间时可进行初始化

    -    malloc仅根据需要申请定量的内存空间

 

2）下面的代码输出什么？为什么？

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

int main()
{
    Test* pn = new Test;   //1、在堆空间申请内存。2、调用构造函数进行初始化。
    Test* pm = (Test*)malloc(sizeof(Test)); //pm只指向一片内存空间，不是合法对象
    return 0;
}

 

编程实验
new和malloc的区别
55-1.cpp
#include <iostream>
#include <string>
#include <cstdlib>

using namespace std;

class Test
{
    int* mp;
public:
    Test()
    {
        cout << "Test::Test()" << endl;
        
        mp = new int(100);
        
        cout << *mp << endl;
    }
    
    ~Test()
    {
        delete mp;
        
        cout << "~Test::Test()" << endl;
    }
};

int main()
{
    Test* pn = new Test;
    Test* pm = (Test*)malloc(sizeof(Test));
    
    //free(pn);  //不调用析构函数，无法释放mp指向的堆空间，造成内存泄露
    delete pn;
    free(pm);
    
    return 0;
}

操作：

1) g++ 55-1.cpp -o 55-1.out编译正确，打印结果：

Test::Test()
100
~Test::Test()

分析：

        new Test;会触发构造函数创建类，但是malloc不会，它仅仅是分配内存。

        delete pn;销毁指向对空间内存前会先调用类的析构函数，然后再释放申请的堆内存。但是free(pm)直接释放堆内存，如果构造函数中没有释放类中分配的内存，会发生内存泄露。

 

3）new和malloc的区别

    -    new在所有C++编译器中都被支持

    -    malloc在某些系统开发中是不能调用(没有对应的库函数)

    -    new能够触发构造函数的调用

    -    malloc仅分配需要的内存空间

    -    对象的创建只能使用new

    -    malloc不适合面向对象开发

 

4）下面的代码输出什么？为什么？

int main()
{
    Test* pn = new Test;    //触发构造函数，创建类
    Test* pm = (Test*)malloc(sizeof(Test));    //不触发构造函数，没有类产生
 
    delete pn;    //调用析构函数，然后释放pn指向的堆内存
    free(pm);    //直接释放pm指向的堆内存
    
    return 0;
}

5）delete和free的区别

    -    delete在所有C++编译器中都被支持

    -    free在某些系统开发中是不能调用

    -    delete能够触发析构函数的调用

    -    free仅归还之前分配的内存空间

    -    对象的销毁只能使用delete

    -    free不适合面向对象开发

 

二、关于虚函数

            构造函数是否可以成为虚函数？

            析构函数是否可以成为虚函数？

 

1）构造函数不可能成为虚函数

    -    在构造函数执行结束后，虚函数表指针才会被正确的初始化

2）析构函数可以成为虚函数

    -    建议在设计类时将析构函数声明为虚函数

 

编程实验
构造，析构，虚函数
55-2.cpp
#include <iostream>
#include <string>

using namespace std;

class Base
{
public:
    virtual Base()    //将构造函数声明为虚函数
    {
        cout << "Base()" << endl;
    }
    
    virtual void func() 
    {
        cout << "Base::func()" << endl;
    }
    
    ~Base()  //可以成为虚函数
    {
 
        cout << "~Base()" << endl;
    }
};


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


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

操作：

1) 将Base()构造函数声明为虚函数，g++ 55-2.cpp -o 55-2.out编译错误：

55-2.cpp:9:15: error: constructors cannot be declared virtual

2) 修改代码：

#include <iostream>
#include <string>

using namespace std;

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

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

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

g++ 55-2.cpp -o 55-2.out编译正常，打印结果：

Base()
Derived()   
~Base()

分析：

        子类Derived在堆空间创建对象，用父类Base*指针指向堆空间。delete p时释放p指向的堆空间(这里释放的是父类指针Base*)，此时编译器认为只调用父类的析构函数(只打印~Base()了)。如果需要在子类析构函数释放内存，可能会有内存泄露。

        我们期望的是先调用子类析构函数，在调用父类析构函数。但实际只调用父类析构函数。

 

解决办法：将父类析构函数声明为虚构函数(virtual)，代码如下：

#include <iostream>
#include <string>

using namespace std;

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

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

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

g++ 55-2.cpp -o 55-2.out编译正确，打印结果：

Base()
Derived()    
~Derived()    
~Base()

分析：

        将继承的父类声明为析构函数，杜绝了父类指针指向子类对象时，父类指针被销毁无法自动调用子类析构函数。

        给父类析构函数声明为虚函数后，会释放父类指针指向的实际对象(这个例子是Derived对象本身)。

 

工程中：父类析构函数一般都声明为虚析构函数，防止上述情况，如果子类有些内存无法释放代码不能执行，会造成内存泄露。

 

        构造函数中是否可以发生多态？

        析构函数中是否可以发生多态？

 

3）构造函数中不可能发生多态行为

    -    在构造函数执行时，虚函数表指针未被正确初始化

4）析构函数中不可能发生多态行为

    -    在析构函数执行时，虚函数表指针已经被销毁

 

            构造函数和析构函数中不能发生多态行为，只调用当前类中定义的函数版本

 

测试：55-2.cpp，添加func()：

#include <iostream>
#include <string>

using namespace std;

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

class Derived : public Base
{
public:
    Derived()
    {
        cout << "Derived()" << endl;
    
        func();
    }
    
    virtual void func()
    {
        cout << "Derived::func()" << endl;
    }
    
    virtual ~Derived()    //将父类析构函数声明为虚函数
    {
        func();
    
        cout << "~Derived()" << endl;
    }
};

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

g++ 55-2.cpp -o 55-2.out编译正确，打印结果：

Base()
Base::func()
Derived()
Derived::func()
Derived::func()
~Derived()
Base::func()
~Base()

分析：

        构造函数和析构函数被声明为虚函数后，并没有发生多态行为，各自调用各自类的构造函数或者析构函数。

一个对象只有一个虚函数表。虚表内容会不会改变，取决于构造函数。

涉及到C++对象模型

 

三、关于继承中的强制类型转换

            继承中如何正确的使用强制类型转换？

 

1）dynamic_cast是与继承相关的类型转换关键字

2）dynamic_cast要求相关的类中必须有虚函数

3）用于有直接或者间接继承关系的指针（引用）之间

    -    指针：

        * 转换成功：得到目标类型的指针

        * 转换失败：得到一个空指针

    -    引用：

        * 转换成功：得到目标类型的引用

        * 转换失败：得到一个异常操作信息

4）编译器会检查dynamic_cast的使用是否正确

5）类型转换的结果只可能在运行阶段才能得到

 

编程实验
dynamic_cast的使用
55-3.cpp
#include <iostream>
#include <string>

using namespace std;

class Base
{
public:
    Base()
    {
        cout << "Base::Base()" << endl;
    }
    
    //virtual ~Base()   //工程经验，父类的析构函数都生成为虚析构函数
    ~Base()
    {
        cout << "Base::~Base()" << endl;
    }
};

class Derived : public Base
{

};

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

操作：

1) g++ 55-3.cpp -o 55-3.out编译错误：

55-3.cpp: In function 'int main()':
55-3.cpp:29:16: error: invalid conversion from 'Base*' to 'Derived*'
    Derived* pd = p;
错误：从'Base'非法转换到'Derived*

分析：
        不可以用父类指针初始化子类指针。
2) 使用强制转换dynamic_cast<Derived*>： 

#include <iostream>
#include <string>

using namespace std;

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

class Derived : public Base
{

};

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

g++ 55-3.cpp -o 55-3.out编译错误：

55-3.cpp:29:40: error: cannot dynamic_cast 'p' (of type 'calss Base*') to type 'class Derived*'(source type is not polymorphic)
错误：不能用 dynamic_cast 将'p'转换成 'class Derived*'类型(原类型不是多态)

因为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 Derived;    //父类指针指向子类对象
    
    Derived* pd = dynamic_cast<Derived*>(p);
    
    cout << "pd = " << pd << endl;
    
    return 0;
}

打印结果：

Base::Base()
pd = 0x8bda008

分析：

        这里的父类指针Base* p指向了子类Derived，程序运行时可以转换成功。

 

如果父类指针Base* p指向了父类Base，在进行强制转换会如何：

#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);
    
    cout << "pd = " << pd << endl;
    
    return 0;
}

g++ 55-3.cpp -o 55-3.out编译正确，打印结果：

Base::Base()
pd = 0

分析：

        pd是空指针，因为dynamic_cast<Derived*>(p)转换失败。

因此在使用转换后的pd需要判断指针是否为空。

int main()
{
    Base* p = new Base;    //父类指针指向父类对象
    
    Derived* pd = dynamic_cast<Derived*>(p);
    
    if( pd != NULL )
    {
        cout << "pd = " << pd << endl;
    }
    else
    {
        cout << "Cast error!" << endl;
    }
        
    return 0;
}

打印结果：

Base::Base()
Cast error!

分析：

        不能用子类指针指向父类对象。在单继承+多接口时很常用。

 

小结

1) new/delete会触发构造函数或者析构函数的调用

2) 构造函数不能成为虚函数

3) 析构函数可以成为虚函数

4) 构造函数和析构函数中都无法产生多态行为

5) dynamic_cast是与继承相关的专用转换关键字

工程中：父类析构函数一般都声明为虚析构函数，防止上述情况，如果子类有些内存无法释放代码不能执行，会造成内存泄露。

喂你的猴子跑了
关注
专栏目录
net55-r8168-8.045a-napi.x86-64 安装esxi时候的No Network Adapters报错解决
03-16
本文将详细解析这个问题及其解决方案。 首先，让我们来理解这个问题的本质。"No Network Adapters"错误通常出现在ESXi安装过程中，当系统无法识别或找到可用的网络硬件时。这可能是由于驱动程序不兼容或者缺少必要...
apache-tomcat-8.5.55-src:tomcat原始码解析
03-23
apache-tomcat-8.5.55 杰克1.8.171 专家 主意 ##原始代码构建步骤 步骤一：官网下载tomcat源代码（ 步骤二：IDEA新建Maven项目apache-tomcat-8.5.55-src，基于JDK 1.8.171，将解压后的tomcat源码复制到该项目下。...
C++笔记 第五十五课 经典问题解析四---狄泰学院
YLC_慕类的博客
11-29 235
如果在阅读过程中发现有错误，望评论指正，希望大家一起学习，一起进步。 学习C++编译环境：Linux 第五十五课 经典问题解析四 1.关于动态内存分配 new和malloc的区别是什么？ delete和free的区别是什么？ new关键字与malloc函数的区别 new关键字是C++的一部分 malloc是由C库提供的函数 new以具体类型为单位进行内存分配 malloc以字节为单位进行内存分配 ...
狄泰C++课程学习笔记：第三十二课：C++标准库
许的博客
01-20 216
  相较于C编译环境中的C库（如stdio.h/stdlib.h等）而言，C++编译环境也有着自己的C++标准库；那么针对C++标准库，大概有以下几点需要着重注意：   1. C++语言本身和C++标准库并没有什么直接的关系，C++标准库是无数个前辈们基于C++语言去实现的一系列常用的/实用的功能类和函数的集合。   2. C++编译环境本身包括：编译模块和库2大部分；编译模块中又包含C++的...
狄泰C++课程学习笔记：第十课：C++中的新成员
许的博客
06-23 372
1、用于动态内存空间申请和释放的new/delete关键字的引入对应于C中用于动态内存申请和释放的库函数malloc/free来说，C++中引入了全新的概念，直接以源生关键字的方式支持了动态内存的申请和释放，相较于C中的申请和释放，二者特点特性对比如下：    * C：动态内存的申请是以字节为单位进行的   如：int* p = malloc(sizeof(int));      C++：动态内存...
C++笔记 第五十三课 被遗弃的多重继承（上）---狄泰学院
YLC_慕类的博客
11-29 227
如果在阅读过程中发现有错误，望评论指正，希望大家一起学习，一起进步。 学习C++编译环境：Linux 第五十三课 被遗弃的多重继承（上） 1.问题 C++中是否允许一个类继承自多个父类？允许 2.C++支持编写多重继承的代码 一个子类可以拥有多个父类 子类拥有父类的成员变量 子类继承所有父类的成员函数 子类对象可以当做任意父类对象使用 多重继承的语法规则 多重继承的本质与单继承相同！ 53-1...
C++笔记 第五十四课 被遗弃的多重继承（下）---狄泰学院
YLC_慕类的博客
11-29 248
如果在阅读过程中发现有错误，望评论指正，希望大家一起学习，一起进步。 学习C++编译环境：Linux 第五十四课 被遗弃的多重继承（下） 1.多重继承的问题三 多重继承可能产生多个虚函数表 54-1 多重继承问题三 #include &lt;iostream&gt; #include &lt;string&gt; using namespace std; class BaseA { public...
query-string-for-all:解析和字符串化 URL 查询字符串
08-04
解析和字符串化 URL 安装 $ npm install query-string-for-all 这是一个的分支，其中包含所有原始代码和 ES6 NPM 依赖项编译为 ES5，因此它可以在 IE 11 等较旧的浏览器中使用。 用法 const queryString = require...
AoE2ScenarioParser-0.1.55-py3-none-any.whl.zip
最新发布
06-17
AoE2ScenarioParser-0.1.55-py3-none-any.whl.zip是一个压缩包文件，其中包含了一个Python的可分发包，主要用于解析《帝国时代2》（Age of Empires II）的游戏场景文件。这个包的名字揭示了它是一个专门为Python 3...
199bbdcb-2b10-4418-ade0-4de10b6ab55-1.zip
02-20
很抱歉，根据您提供的信息，"199bbdcb-2b10-4418-ade0-4de10b6ab55-1.zip" 是一个压缩包文件的名称，但没有提供具体的描述或标签来指示其内容。同样，压缩包内的子文件"feed8dd1-7f37-4aea-be65-2b61e5.html"也没有...
C++入门教程（五十五）：构造函数和初始化列表
小古银的博客
04-05 325
小古银的官方网站（完整教程）：http://www.xiaoguyin.com/ C++入门教程视频：https://www.bilibili.com/video/av20868986/ 目录 目录 构造函数 初始化列表 基础示例 基础讲解 重载构造函数 基础示例 基础讲解 最后的注意 巩固练习 下面先总结一下构造函数的相关知识： 成员变量都是在构造函数内被创...
C++笔记 第五十一课 C++对象模型分析（下）---狄泰学院
YLC_慕类的博客
11-29 219
如果在阅读过程中发现有错误，望评论指正，希望大家一起学习，一起进步。 学习C++编译环境：Linux 第五十一课 C++对象模型分析（下） 1.继承对象模型 在C++编译器的内部类可以理解为结构体 子类是由父类成员叠加子类新成员得到的 51-1 继承对象模型初探 #include &lt;iostream&gt; #include &lt;string&gt; using namespace s...
C++笔记 第五十九课 类模板深度剖析---狄泰学院
YLC_慕类的博客
11-30 259
如果在阅读过程中发现有错误，望评论指正，希望大家一起学习，一起进步。 学习C++编译环境：Linux 第五十九课 类模板深度剖析 1.多参数类模板 类模板可以定义任意多个不同的类型参数 类模板可以被特化 指定类模板的特定实现 部分类型参数必须显示指定 根据类型参数分开实现类模板 类模板的特化类型 部分特化-用特定规则约数类型参数 完全特化-完全显示指定类型参数 59-1 类模板的特化—重点程...
使用dynamic_cast报错source type is not polymorphic
QingTC
10-02 9786
#include  using namespace std;  class C{   public:   virtual ~C(){}////////////基类必须要加这个虚函数，不然就会报以下错误，  };  class A:public C{  };  class B:public C{  }; int main(){ C* pa=new A(); B* pb=dyn
std::dynamic_pointer_cast 遭遇错误 source type is not polymorphic
wwyyxx26的专栏
03-28 3993
std::dynamic_pointer_cast 遭遇错误 source type is not polymorphic 原因就是要进行转换的类型不是多态的，即没有虚函数 简单的将基类的析构定义成基类就行了 virtual ~A() = default; ...
C/C++：类型转换
test1280
05-26 707
C++：dynamic_cast、static_cast
c++ 类型转换与explicit
weixin_42923076的博客
05-09 558
c++ 类型转换与explicit 本文试图搞清楚这样2个问题： c++ 类型转换有哪些？作用分别是什么？实际工程中应该怎么用？ 经常查看标准库源码的同学会发现标准库中很多类构造函数会带有explicit声明，explicit关键字是为了做什么的？ 一、c++的类型转换简介 可不要上来就说4种类型转换昂。。类型转换按照触发条件分可分为：隐式类型转换，显式类型转换；而按照行为分可分为：static，dynamic，const，reinterpret。我们先按照行为划分介绍4种类型转换： 1. static
为什么C++构造函数不能是虚函数
hanzhen7541的博客
08-07 896
这是一个“鸡生蛋还是蛋生鸡”的问题。 首先我们要明白，虚函数是如何调用的。如果一个类有虚函数，那么必然对应一个虚函数表vtable，这个虚函数表的指针指向的是虚函数的地址。当一个基类指针想要调用派生类的虚函数的时候，需要通过这个虚函数表来查找调用这个派生类的虚函数。 那么，既然知道了虚函数是如何调用的，那么虚函数表是什么时候形成的呢？它是构造函数初始化示例的时候进行初始化的，也就是说构造函数初...
CastError: Cast to string failed for value “{}“ at path “xxx“ for model “xxxModel“
wzp20092009的博客
11-15 1655
在执行mongodb查询语句时报错`CastError: Cast to string failed for value "{}" at path "xxx" for model "xxxModel"`
JavaScript编程：55个经典实用技巧解析
"这篇文档汇总了JavaScript中55个常用的经典技巧，涵盖了页面交互、安全防护、用户体验等多个方面。" 1. **鼠标右键屏蔽**：通过`oncontextmenu`事件，可以禁止用户在页面上右键点击，这通常用于防止用户看到或使用...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值