【C++】55.经典问题分析4

问题1：

new和malloc的区别是什么？

delete和free的区别是什么？

    Test* pn = new Test; // 生成合法对象
    Test* pm = (Test*)malloc(sizeof(Test));  // 只是申请了空间，但是没有具体对象
    
    delete pn;
    free(pm);

 

注意：

Free可以释放new申请的空间，但是不会触发析构函数，容易造成内存泄漏

（不要混用，不要混用！！！）所以需要配对成对使用！

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(pm);
    
    return 0;
}

问题2：

构造函数是否能成为虚函数？

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

 

析构函数成为虚函数的意义：

工程上常用把父类的析构函数为虚函数，因为这样的话可以避免在释放的时候不会把子类的的忘记释放析构。

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


int main()
{
    Base* p = new Derived();
    
    // ...
    
    delete p; 
    //父类析构函数没有声明virtual情况下 ,编译器根据指针的类型调用该类型的析构函数（Base）
    // 不会调用（Derived）的析构函数
    return 0;
}

问题3：

构造函数中是否能够发生多态？

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

 

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()
Derived::func()
~Base()
Base::func()

 

问题4：

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

Base* p = new Base();
Derived* pd = dynamic_cast<Derived*>(p);  //?? 这样是不行的
//不能用子类指向父类