对象的生存期

 

对象从产生到结束的这段时间就是它的生存期。在对象生存期内，对象将保持它的值，知道被更新为止。

 

静态生存期

这种生存期与程序的运行期相同。

在文件作用域中声明的对象具有这种生存期。

在函数内部声明静态生存期的对象，要冠以关键字static

 

动态生存期

块作用域声明的对象是动态生存期的对象（习惯称局部生存期对象）

开始与程序执行到声明点时，结束语命名该标识符的作用域结束处。

 

16

例：

1. #include <iostream.h>
2. void fun ();
3. void main()
4. {
5.     fun();
6.     fun();  //运行2次
7. }
8. void fun()
9. {
10.     static int a=1;   //第二次运行fun()的时候由于a=1是静态所以不再执行
11.     int i=5;  //i是动态生存期 
12.     a++;        //a是静态生存期 第二次运行取的第一次退出时候的值2
13.     i++;
14.     cout <<”i=”<<i<<”,a=”<<a<<endl;
15. }

运行结果

i=6,a=2

i=6,a=3

这个例子说明静态变量只有在第一次运行的时候才初始化

 

变量的生存期与可见性

1. #include<iostream.h>
2. int i=1;  //i为全局变量，具有静态生存期
3. void main(void)
4. {
5.     static int a;  //静态局部变量，有全局寿命，局部可见。
6.     int b= -10;     //b,c为局部变量，具有动态生存期。
7.     int c= 0;
8. void other(void);
9. cout <<”---MAIN---/n”;
10. cout<<”i:”<<i<<”a:”<<a<<”b:”<<b<<”c:”<<c<<endl;
11. c=c+8; other();
12. cout <<”---MAIN---/n”;
13. cout <<”i:”<<i<<”a:”<<a<<”b:”<<b<<”c:”<<c<<endl;
14. i=i+10;other();
15. }
16. void other(void)
17. {
18.     static int a=2;
19. static int b;
20. //a,b,为静态局部变量，具有全局寿命，局部可见。
21. //只第一次进入函数时被初始化。
22. int c=10;   //c为局部变量，具有动态生存期。
23.             //每次进入函数都初始化。
24. a=a+2;i=i+32;c=c+5;
25. cout<<”—OTHER--/n”;
26. cout<<”i:”<<i<<”a:”<<a<<”b:”<<b<<”c:”<<c<<endl;
27. b=a;
28. }

 

例：具有静态、动态生存期对象的时钟程序

1. #include<iostream.h>
2. class Clock //时钟类声明
3. {
4. public:  //外部借口
5.     Clock();
6.     void SetTime(int NewH,intNewM,intNewS);
7.     //三个形参均具有函数原型作用域
8.     void ShowTime();
9.     ~Clock(){}
10. private:
11.     int Hour,Minute,Sencond;
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. }
31. Clock globClock;  //声明对象globClock,具有静态生存期，文件作用域
32. void main()  //主函数
33. {
34.     cout <<””First time output:”endl;
35. //引用具有文件作用域的对象globClock:
36. globClock.ShowTime();  //对象的成员函数具有类作用域
37. globClock.SetTime(8,30,30);
38. Clock myClock(globClock);  //声明具有块作用域的对象
39. myClock
40. cout<<”Second time output:”<<endl;
41. myclock.ShowTime();   //引用具有块作用域的对象myClock
42. }

 

数据与函数

数据存储在局部对象中，通过参数传递实现共享——函数间的参数传递

方法一：数据存储在全局对象中

例：

 

1. #include <iostream.h>
2. int global;  //全局的文件作用域，在哪个都能使用
3. void f()
4. {
5.     global=5;
6. }
7. void g()
8. {   
9.     cout<<global<<endl;
10. }
11. int main()
12. {
13.     f();
14.     g(); //输出5
15.     return 0l
16. }

方法二：将数据和使用数据的函数封装在类里面

例：

1. #include<iostream.h>
2. class Application
3. {
4. public:
5.     void f(); void g();
6. private:
7.     int global;  //类作用域
8. };
9. void Application::f()
10. {
11.     global=5;
12. }
13. void Application::g()
14. {   
15.     cout<<global<<endl;
16. }
17. int main()
18. {
19.     Application
20.     MyApp;
21.     MyApp.f();
22.     MyApp.g();
23.     return 0;
24. }