第五十五课：经典问题分析四（new与malloc，构造函数，析构函数，虚函数，多态，dynamic_cast）---狄泰软件学院

一、
new和malloc的区别是什么？
delete和free的区别是什么？

new关键字与malloc函数的区别

1. new关键字是C++的一部分
2. malloc是由C库提供的函数
3. new一具体类型为单位进行内存分配
4. malloc一字节为单位进行内存分配
5. new在申请内存空间时可进行初始化
6. malloc仅根据需要申请定量的内存空间

实例分析1：new和malloc的区别

#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));
    //malloc申请了内存空间，但是没生成对象。
    
    delete pn;
    free(pm);
    
    return 0;
}
Test::Test()
100
~Test::Test()

new和malloc的区别

1. new在所有C++编译器中都被支持
2. malloc在某些系统开发中是不能调用的
3. new能够触发构造函数的调用
4. malloc仅分配需要的内存空间
5. 对象的创建只能使用new
6. malloc不适合面向对象开发

二、关于虚函数
构造函数是否可以为虚函数？
析构函数是否可以成为虚函数？

（1）构造函数是不可能成为虚函数，在构造函数执行结束后，虚函数表指针才会被正确的初始化。
（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()
    {
        func();
        
        cout << "~Base()" << endl;
    }
};


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


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


如果父类的析构函数没有声明为virtual时
     ~Base()
    {
        func();
        
        cout << "~Base()" << endl;
    }
输出结果为：
Base()
Base::func()
Derived()
Derived::func()
Base::func()
~Base()
通过Base* p = new Derived();delete p;时，编译器只是根据指针p的类型（父类）调用父类的析构函数，简单暴力，而把子类的析构函数忘了调用。子类继承父类，析构时应该先析构自己，后析构别人。

三、
构造函数中是否可以发生多态？析构函数中是否可以发生多态？
（1）构造函数中不可能发生多态行为，在构造函数执行时，虚函数表指针未被正确初始化。
（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()
    {
        func();//构造函数和析构函数中不能发生多态行为，只调用当前类中定义的函数版本。
        
        cout << "~Base()" << endl;
    }
};


class Derived : public Base
{
public:
    Derived()
    {
        cout << "Derived()" << endl;
        
        func();
    }
    
    virtual void func()
    {
        cout << "Derived::func()" << endl;
    }
    
    ~Derived()
    {
        func();//构造函数和析构函数中不能发生多态行为，只调用当前类中定义的函数版本。
        
        cout << "~Derived()" << endl;
    }
};


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

Base()
Base::func()//构造函数和析构函数中不能发生多态行为，只调用当前类中定义的函数版本。
Derived()
Derived::func()//构造函数和析构函数中不能发生多态行为，只调用当前类中定义的函数版本。
Derived::func()//构造函数和析构函数中不能发生多态行为，只调用当前类中定义的函数版本。
~Derived()
Base::func()//构造函数和析构函数中不能发生多态行为，只调用当前类中定义的函数版本。
~Base()

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

dynamic_cast是与继承相关的类型转换关键字
dynamic_cast要求相关的类中必须有虚函数
用于直接或者间接继承关系的指针（引用）之间
(1)指针：转换成功：得到目标类型的指针，转换失败：得到一个空指针
（2）引用：转换成功：得到目标类型的引用；转换失败：得到一个异常操作信息。

编译器会检查dynamic_cast的使用是否正确
类型转换的结果只能在运行阶段才能得到。

实例分析3：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;
}
Base::Base()
Cast error!//强制类型转换失败，返回一个空指针。
Base::~Base()


    virtual ~Base()
    {
        cout << "Base::~Base()" << endl;
    }
     virtual去掉的话，类中没有虚函数，那么编译会报错，因为没有满足dynamic_cast中必须要有虚函数。

总结：

1. new/delete会触发构造函数或者析构函数的调用
2. 构造函数不能成为虚函数
3. 析构函数可以成为虚函数
4. 构造函数和析构函数中都无法产生多态行为
5. dynamic_cast是与继承相关的专用转换关键字。