55_经典问题解析四

1. 关于动态内存分配

问题：new和malloc的区别是什么？
delete和free的区别是什么？

new关键字和malloc函数的区别：
(1) new关键字是C++的一部分，malloc是由C库提供的函数；
(2) new以具体类型为单位进行内存分配，malloc以字节为单位进行内存分配
(3) new在申请内存空间时可以进行初始化，malloc仅根据需要申请定量的内存空间

编程说明：new和malloc的区别

#include 
#include 
#include 

using namespace std;

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

int main()
{
    Test* pn = new Test;    // pn指针指向Test对象
    Test* pm = (Test*)malloc(sizeof(Test)); // pm指针指向一片堆内存空间，没有指向合法的Test对象
    
    delete pn;      // 调用析构函数 
    free(pm);       // 只释放空间，不会调用析构函数

    return 0;
}

总结：new和malloc的区别：
(1) new在所有的C++编译器中都被支持
(2) malloc在某些系统开发中不能表用
(3) new能够触发构造函数的调用
(4) malloc仅分配需要的内存空间
(5) 对象的创建只能使用new
(6) malloc不适合面向对象开发
delete和free的区别：
(1) delete在所有的C++编译器中都被支持
(2) free在某些系统开发中不能表用
(3) delete能够触发析构函数的调用
(4) free仅归还之前分配的内存空间
(5) 对象的销毁只能使用delete
(6) free不适合面向对象开发

2. 关于虚函数

问题：构造函数是否可以成为虚函数？
析构函数是否可以成为虚函数？

构造函数不可能成为虚函数，在构造函数执行结束后，虚函数表指针才会被正确初始化；
析构函数可能成为虚函数，析构函数在对象销毁之前被调用，因此虚函数指针是正确指向虚函数表。建议在设计类时将析构函数声明为虚函数。
编程说明：构造函数、析构函数、虚函数

#include 
#include 

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;
    }
    
    void func()
    {
        cout << "Derived::func()" << endl;
    }
    
    ~Derived()
    {
        cout << "~Derived()" << endl;
    }
};

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

    return 0;
}

输出结果：

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

总结：此时的指针p为Base(父类)， 创建的对象为Derived(子类)，根据赋值兼容性原则，可以创建成功。但是在delete p时，如果析构函数不是虚函数，则编译器判断p的类型为Base(父类)，只调用Base(父类)的析构函数，却没有调用Derived(子类)的析构函数。当析构函数为虚函数时，根据多态的原则，编译器会根据p所指向对象的实际的类型来决定如何调用析构函数，在这里会先调用子类的析构函数，然后调用父类的析构函数。
工程中，一般父类的析构函数会声明为虚函数

问题： 构造函数中是否可以发生多态？
析构函数中是否可以发生多态？

构造函数中不可能发生多态行为：在构造函数执行时，虚函数表指针未被正确初始化
析构函数中不可能发生多态行为，在析构函数执行时，虚函数表指针已经被销毁
总结：构造函数和析构函数不能发生多态行为，只调用当前类中定义的函数版本

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

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

编程说明：dynamic_cast的使用

#include 
#include 

using namespace std;

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

class Derived : public Base
{

};

int main()
{
    Base* pbd = new Derived;
    Base* pbb = new Base;
    
    Derived* pdd = dynamic_cast(pbd);
    Derived* pdb = dynamic_cast(pbb);
    
    cout << "pdd(由父类指针指向子类对象，然后强制转换为子类指针) : " << pdd << endl;
    cout << "pdb(由父类指针指向父类对象，然后强制转换为子类指针) : " << pdb << endl;
    
    if (pdb != NULL)    // 转换小技巧
    {
        cout << pdb << endl;
    }
    else
    {
        cout << "Cast error!!!" << endl;
    }
    
    delete pbd;
    delete pbb;
    
    return 0;
}

输出结果

Base::Base()
Base::Base()
pdd(由父类指针指向子类对象，然后强制转换为子类指针) : 0x811e008
pdb(由父类指针指向父类对象，然后强制转换为子类指针) : 0
Cast error!!!
Base::~Base()
Base::~Base()

4. 小结

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