#include <iostream>
#include <string>
#include <cstdlib>
using namespace std;
class Test
{
  int* mp; //為了說明 free() 可能造成內存泄漏問題而添加的成員變量；
public:
  Test()
  {
    cout << "Test::Test()" << endl;
    mp = new int(100); // 申請 4 個字節(jié)堆空間并初始化為 100；
    cout << *mp << endl;
  }
  ~Test()
  {
    delete mp; // 析構函數(shù)歸還堆空間；但是如果僅僅用 free() 函數(shù)歸還堆空間，這里析構函數(shù)沒有調用，則對象沒有摧毀，那么就造成了堆空間泄漏，這在大型項目開發(fā)中是不可原諒的；
    cout << "~Test::Test()" << endl;
  }
};
int main()
{
  Test* pn = new Test; // 第一步申請堆空間，第二步（申請成功后）在堆空間上調用構造函數(shù)、因為需要初始化；
  Test* pm = (Test*)malloc(sizeof(Test)); // 這行代碼運行完后，pm 并沒有指向合法的對象，它僅僅指向一片內存空間而已，這個時候這片內存空間不能夠成為一片合法的對象，因為就沒有對象；
  delete pn; // 動態(tài)歸還堆空間；第一步 delete 觸發(fā)析構函數(shù)調用，摧毀對象，第二步歸還堆空間；在歸還堆空間的時候，要先摧毀掉對象，否則容易出現(xiàn)內存泄漏；
  free(pm); // 動態(tài)規(guī)劃堆空間；僅歸還堆空間，不觸發(fā)析構函數(shù)調用；這里不能用 delete pm，因為這樣會對非法對象調用構造函數(shù)，而對于析構函數(shù)中的 delete mp 來說，這樣的影響是深遠的，不知道什么時候就會帶來 bug，且不可調試，只能通過“代碼走查”的方式來檢查是不是混用了兩種類型的申請釋放堆空間函數(shù)；
  return 0;
}

int main()
{
  Test* pn = new Test; // 調用構造函數(shù)；
  test* pm = (Test*)malloc(sizeof(Test)); // 僅申請堆空間；
  delete pn; // 調用析構函數(shù)；
  free(pm); // 僅釋放堆空間；
   return 0;
}

#include <iostream>
#include <string>
using namespace std;
class Base
{
public:
  Base() // 若申請為析構函數(shù)，則編譯器在此處顯示：error:constructors cannot be declared virtual.
  {
    cout << "Base()" << endl;
  }
  virtual void func() 
  {
    cout << "Base::func()" << endl;
  }
  virtual ~Base() // 申請為虛函數(shù)時，編譯器無顯示
  {  
    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; // 期望調用完子類析構函數(shù)再調用父類的析構函數(shù)；但是如果父類沒有申請為析構函數(shù)，則只調用父類析構函數(shù)；這是因為此時刪除的是一個父類的指針，由于并沒有將析構函數(shù)申請為 virtual，因此在這樣情況下，編譯器直接根據(jù)指針 p 的類型來決定調用哪一個構造函數(shù)，由于指針 p 的類型是父類的類型，所以編譯器直接暴力認為調用父類構造函數(shù)就可以了；當將父類的虛函數(shù)聲明為 virtual 時，編譯器就不會簡單的根據(jù)指針 p 的類型來簡單調用父類的或者是子類的析構函數(shù)了，這個時候由于析構函數(shù)是虛函數(shù)，所以在執(zhí)行這行代碼的時候，編譯器會根據(jù)指針 p 指向的實際對象來決定如何調用析構函數(shù)，這是多態(tài)；
  return 0;
}

#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(); // 打印 Base()，Base::func()，Derived()，Derived::func()，                
  // ...
  delete p; // 打印 Derived::func()，~Derived()，Base::func()， ~Base()；
  return 0;
}

#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 = p; // 編譯器顯示：error:invalid conversion from 'Base*' to 'Derived*'；
           // 未有虛函數(shù)時，用 dynamic_cast 轉換，編譯器顯示：error: cannot dynamic_cast 'p' (of type 'class Base*') to type 'Derived*' (source type is not polymorphic（多態(tài)的）)
           // 有虛函數(shù)且用了 dynamic_cast 也要判斷 pd 不為空；
*/
  Base* p = new Base;
  Derived* pd = dynamic_cast<Derived*>(p); // 不合法，不能使用子類指針，指向父類對象；編譯器編譯階不報錯；但是運行時 pd = 0； 意味著此處強制類型轉換不成功；
  if( pd != NULL ) // 這樣的判斷很有必要；
  {
    cout << "pd = " << pd << endl;
  }
  else
  {
    cout << "Cast error!" << endl;
  }
  delete p;
  return 0;
}