第55课 经典问题解析（四）

1. 关于动态内存分配

（1）new和malloc的区别

（2）delete/free的区别

【编程实验】new和malloc的区别

#include <iostream>
#include <string>
#include <cstdlib> //for malloc\free函数。同时说明这两者都是函数，而不是关键字！
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)); //不会调用构造函数

    delete pn; //会调用析构函数。如果这里混用free，则会造成内存泄漏！

    free(pm);  //如果这里误用delete来释放pm所指的空间时，会同时调用
               //析构函数，但因mp指针所指空间是未知，出现误删除的bug。

    return 0;
}

2. 关于虚函数

（1）构造函数：

　　①构造函数本身不可能成为虚函数，因为在构造函数执行结束后，虚函数表指针才被正确的初始化。

　　②在构造函数中调用其他虚函数时，不会发生多态。因为在构造函数执行期间，虚函数表指针未被正确初始化。所以当调用虚函数时，只会调用本类中定义的那个函数版本。

（2）析构函数：

　　①析构函数本身可以成为虚函数，建议在设计类时将析构函数声明为虚函数，特别是要作为父类的类。

　　②析构函数中调用其他虚函数时，也不会发生多态，因为析构阶段虚函数表指针己经被销毁。所以当调用虚函数时，只会调用本类中定义的那个函数版本，即静态绑定了。

【编程实验】构造、析构和虚函数

#include <iostream>
#include <string>

using namespace std;

class Base
{
public:
    Base()  //不能成为虚函数，哪怕加了virtual;
    {
        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(); //注意是父类指针，如果这里直接声明为Derived* p = new  Derived()
                             //则delete p直接调用子类的构造函数。但我们本例的目的之一是为了演示
                             //析构函数的多态，所以声明为父类的针。

    //...
    cout << endl;

    delete p; //delete会调用析构函数。从这行代码看，如果父类中析构函数没被声明为虚函数的话，
              //delete一个父类的指针，由于静态绑定，当然调用的是父类的析构函数，此时会造成
              //Derived的析构函数没被调用。当然，如果父类中析构函数被声明为虚函数，根据多态
              //原理，会调用子类的析构函数，又因析构的特点，会自动先调用父类析构，再调用子类
              //自己的析构函数，从而正确的释放内存。

    return 0;
}

/*输出结果
Base()
Base::func()     //注意，并没有发生多态
Derived()
Derived::func()  //注意，并没有发生多态

Derived::func()  //注意，并没有发生多态
~Derived()
Base::func()     //注意，并没有发生多态
~Base()
*/

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

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

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

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

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

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

【编程实验】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
{
public:

};

int main()
{
    Base* p = new Base;

    //将用父类指针来初始化子类指针（为演示之用，本身这样用就是不完全的！）
    //注意，这里也提醒我们，可以用dynamic_cast来判断一个类是不是另一个类父类的方法。
    //     具体方法Base* p = dynamic_cast(Base* p)(pDerived);即，子类能否转为父类。
    //     如果返回值不为NULL，表示有父子关系。否则没有。
    Derived* pd = dynamic_cast<Derived*>(p); //注意p所指的类中一定要有虚函数
                                             //本例中，析构函数声明为虚函数。

    if(pd != NULL) //转换成功。
    {
        cout << "pd = " << pd << endl;
    }
    else           //转换失败，返回空指针NULL
    {
        cout << "Cast Error!" << endl;
    }

    delete p;

    return 0;
}

/*输出结果
Base::Base()
Cast Error!
Base::~Base()
*/

4. 小结

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

（2）构造函数不能成为虚函数，析构函数可以成为虚函数。

（3）构造函数和析构函数中都无法产生多态行为。

（4）dynamic_cast是与继承相关的专用转换关键字。