c++对象的生命周期

C++ 的new 运算子和C 的malloc 函数都是为了配置内存，但前者比之后者的优点
是，new 不但配置对象所需的内存空间时，同时会引发构造式的执行。

所谓构造式（constructor），就是对象诞生后第一个执行（并且是自动执行）的函数，它
的函数名称必定要与类别名称相同。

相对于构造式，自然就有个析构式（destructor），也就是在对象行将毁灭但未毁灭之前
一刻，最后执行（并且是自动执行）的函数，它的函数名称必定要与类别名称相同，再
在最前面加一个~ 符号。

#include "stdafx.h"
using namespace std;

class CDemo{ 
char name[20]; 
public: 
 CDemo(){ 
  cout<<"class begin !!!"< } 
 CDemo(char * ch) 
 { 
  strcpy(name,ch); 
  cout << "Constructor called for " << name << '\n'; 
 } 
 ~CDemo(){ 
  cout<<"desturctor called for "< }  
}; 

CDemo * func()
{
 CDemo LocalObjectInFunc("LocalObjectInFunc"); // in stack 
 static CDemo StaticObject("StaticObject"); // local static 
 CDemo* pHeapObjectInFunc = new CDemo("HeapObjectInFunc"); // in heap 
 cout << "Inside func" << endl; 
 return pHeapObjectInFunc;
} 

CDemo GlobalObject("GlobalObject"); // global static 

int _tmain(int argc, _TCHAR* argv[])
 {
 CDemo LocalObjectInMain("LocalObjectInMain"); // in stack 
 CDemo* pHeapObjectInMain = new CDemo("HeapObjectInMain"); // in heap 
 cout << "In main, before calling func\n";
 CDemo *cDemo;
 cDemo = func();
 cout << "In main, after calling func\n"; 
 system("pause");
 delete cDemo;
 delete pHeapObjectInMain;
 return 0;
}

以上代码的执行结果是：

Constructor called for GlobalObject
Constructor called for LocalObjectInMain
Constructor called for HeapObjectInMain
In main, before calling func
Constructor called for LocalObjectInFunc
Constructor called for StaticObject
Constructor called for HeapObjectInFunc
Inside func
desturctor called for LocalObjectInFunc
In main, after calling func
请按任意键继续. . .
desturctor called for HeapObjectInFunc
desturctor called for HeapObjectInMain
desturctor called for LocalObjectInMain
desturctor called for StaticObject
desturctor called for GlobalObject
请按任意键继续. . .

所以可以得到以下几个结论：

• 对于全域对象（如本例之GlobalObject），程序一开始，其构造式就先被执行
  （比程序进入点更早）；程序即将结束前其析构式被执行。MFC 程序就有这
  样一个全域对象，通常以application object 称呼。
• 对于区域对象，当对象诞生时，其构造式被执行；当程序流程将离开该对象的
  存活范围（以至于对象将毁灭），其析构式被执行。
• 对于静态（static）对象，当对象诞生时其构造式被执行；当程序将结束时（此
  对象因而将遭致毁灭）其析构式才被执行，但比全域对象的析构式早一步执
  行。
• 对于以new 方式产生出来的区域对象，当对象诞生时其构造式被执行。析构
  式则在对象被delete 时执行（上例程序未示范）。

四种不同的对象生存方式（in stack、in heap、global、local static）

在C++ 中，有四种方法可以产生一个对象。

第一种方法是在栈（stack）之中产生它：

    void MyFunc()
   {
           CFoo foo; // 在堆栈（stack）中产生foo 对象
           ...
    }
第二种方法是在堆（heap）之中产生它：

    void MyFunc()
  {
       ...
      CFoo* pFoo = new CFoo(); // 在堆（heap）中产生对象
   }
第三种方法是产生一个全域对象（同时也必然是个静态对象）：
        CFoo foo; // 在任何函数范围之外做此动作

第四种方法是产生一个区域静态对象：
   void MyFunc()
  {
       static CFoo foo; // 在函数范围（scope）之内的一个静态对象
       ...
  }

    不论任何一种作法，C++ 都会产生一个针对CFoo 构造式的调用动作。前两种情况，C++
在配置内存-- 来自栈（stack）或堆（heap）-- 之后立刻产生一个隐藏的（你的原
代码中看不出来的）构造式调用。第三种情况，由于对象实现于任何「函数活动范围
（function scope）」之外，显然没有地方来安置这样一个构造式调用动作。是的，第三种情况（静态全局对象）的构造式调用动作必须靠startup 码帮忙。startup 码是什么？是更早于程序进入点（main 或WinMain）执行起来的码，由C++ 编译器提供，
被联结到你的程序中。startup 码可能做些像函数库初始化、进程信息设立、I/O stream 产生等等动作，以及对static 对象的初始化动作（也就是调用其构造式）。

    当编译器编译你的程序，发现一个静态对象，它会把这个对象加到一个串行之中。更精确地说则是，编译器不只是加上此静态对象，它还加上一个指针，指向对象之构造式及其参数（如果有的话）。把控制权交给程序进入点（main 或WinMain）之前，startup 码会快速在该串行上移动，调用所有登记有案的构造式并使用登记有案的参数，于是就初始化了你的静态对象。

    第四种情况（区域静态对象）相当类似C 语言中的静态局部变量，只会有一个实体
（instance）产生，而且在固定的内存上（既不是stack 也不是heap）。它的构造式在
控制权第一次移转到其声明处（也就是在MyFunc 第一次被调用）时被调用。