C++程序设计必知：生存期

       自然界中的事物都有产生和消亡，都有生存期，程序中的简单变量和类的对象也一样有它们的生存期，它们也会产生和消亡。对象的生存期分为静态生存期和动态生存期两种。什么叫做静态生存期和动态生存期呢？

       1.静态生存期

       若某个对象它的生存期与程序的运行期相同，我们就说它具有静态生存期，就是说在程序运行期间它都不会释放。

       具有文件作用域的对象都具有静态生存期。

       函数内部具有块作用域的对象怎样才能具有静态生存期呢？我们可以使用关键字static修饰对象。比如，static int x;这个语句就是将x声明为具有静态生存期的变量，也成为静态变量。

       2.动态生存期

       除了上述情况的对象具有静态生存期外，其余对象都具有动态生存期。具有动态生存期的对象产生于声明处，于该对象的作用域结束处释放。

      下面举个例子说明下简单变量和类的对象的生存期，其中涉及到了全局变量和局部变量。

1.     #include <iostream>
2.          using namespace std;
3.          int a=1;           // a为全局变量，它具有静态生存期。
4.          void fun(void);
5.          int main()   
6.          { 
7.                      static int x;    // 局部变量，具有静态生存期，可以叫做静态局部变量，局部可见。
8.                      int y=5;         // y，z为局部变量，具有动态生存期。
9.                      int z=1;
10.   
11.                     cout<<"---MAIN---\n";
12.                     cout<<" a: "<<a<<" x: "<<x<<" y: "<<y<<" z: "<<z<<endl;
13.                     z=z+2;  
14.                     fun();
15.                     cout<<"---MAIN---\n";
16.                     cout<<" a: "<<a<<" x: "<<x<<" y: "<<y<<" z: "<<z<<endl;
17.                     a=a+10;
18.                     fun(); 
19.                     return 0;
20.         }
21.         void fun(void)
22.         {
23.                   // x,y为静态局部变量，具有全局寿命，局部可见。只有第一次进入函数时被初始化。
24.                   static int x=4;
25.                   static int y;
26.                   int z=10;   // z为局部变量，具有动态生存期，每次进入函数时都初始化。
27.                   a=a+20;
28.                   x=x+3;
29.                   z=z+4;
30.                   cout<<"---FUN---\n";
31.                   cout<<" a: "<<a<<" x: "<<x<<" y: "<<y<<" z: "<<z<<endl;
32.                    y=x;
33.         }

       运行结果：
       ---MAIN---
       a: 1 x: 0 y: 5 z: 1
       ---FUN---
       a: 21 x: 7 y: 0 z: 14
       ---MAIN---
       a: 21 x: 0 y: 5 z: 3
       ---FUN---
       a: 51 x: 10 y: 7 z: 14

       这里要说明下，静态局部变量如果没有进行显式初始化，那么它将被默认初始化为0。当第二次进入fun函数时，其静态局部变量x和y将不再初始化，x和y将继续使用fun函数第一次被调用后最后的值来参加下面的运算。具体点说，第一次调用完fun函数后，fun中变量x的值是7，在第二次调用fun函数时，x不会被赋值为4，而是继续使用7作为自己的值。

       用时钟类来举一个例子。

1.          #include <iostream>
2.          using namespace std;
3.          class Clock //时钟类声明
4.         {
5.         public: //外部接口
6.                    Clock();
7.                    void SetTime(int NewH, int NewM, int NewS);   //三个形参均具有函数原型作用域
8.                    void ShowTime();
9.                   ~Clock(){}
10.         private: //私有数据成员
11.                    int Hour,Minute,Second;
12.         };
13.         //时钟类成员函数实现
14.         Clock::Clock() //构造函数
15.         { 
16.                   Hour=0;
17.                   Minute=0;
18.                   Second=0;
19.         }
20.         void Clock::SetTime(int NewH,int NewM,int NewS)
21.         { 
22.                   Hour=NewH;
23.                   Minute=NewM;
24.                   Second=NewS;
25.         }
26.         void Clock::ShowTime()
27.         { 
28.                  cout<<Hour<<":"<<Minute<<":"<<Second<<endl;
29.         }
30.         //声明全局对象g_Clock，具有文件作用域，静态生存期
31.        Clock g_Clock;
32.        int main() //主函数
33.        {
34.                   cout<<"文件作用域的时钟类对象:"<<endl;
35.                   //引用具有文件作用域的对象：
36.                   g_Clock.ShowTime();
37.                   g_Clock.SetTime(10,20,30);
38.  
39.                   Clock myClock(g_Clock);    //声明具有块作用域的对象myClock，并通过默认拷贝构造函数用g_Clock初始化myClock
40.                   cout<<"块作用域的时钟类对象:"<<endl; 
41.                   myClock.ShowTime(); //引用具有块作用域的对象
42.                   return 0;
43.        }

       运行结果：
       文件作用域的时钟类对象:
       0:0:0
       块作用域的时钟类对象:
       10:20:30

       这个程序中定义了具有各种作用域的对象，Clock类声明中，SetTime函数声明的三个参数具有函数原型作用域，数据成员具有类作用域，全局对象g_Clock具有文件作用域，对象myClock具有块作用域。除g_Clock具有静态生存期外，其余均有动态生存期。