对象的创建及生命周期

对象的生命周期是指从对象创建到对象销毁的过程，创建对象时要占用一定的内存空间，对象销毁后要释放相应的内存，因此整个程序占用的内存空间也随着对象的创建和销毁而动态的发生变化。

对象的创建有三种方式，他们创建的对象的生命周期各有不同。

(一)通过定义变量创建对象。

这种情况下，变量的作用域决定了对象的生命周期，当进入变量的作用域时，对象被创建，退出变量作用域时，对象被销毁。

全局变量的作用域时整个程序，声明为全局变量的对象在调用main函数之前被创建，退出main函数之后被销毁。

静态变量有文件作用域，不是整个程序。但静态变量存储在全局/静态数据区中，在程序开始时已经分配好。因此，声明为静态变量的对象在第一次进入作用域时被创建，知道程序退出时销毁。

1 #include <stdio.h>
 2 #include <stdlib.h>
 3 
 4 class A{
 5 public:
 6     A(){printf("A created. n");}
 7     ~A(){printf("A destroyed. n");}
 8 };
 9 
10 class B{
11 public:
12     B(){printf("B created. n");}
13     ~B(){printf("B destroyed. n");}
14 };
15 
16 A globalA;
17 
18 int foo(void)
19 {
20     printf("nfoo()    ----------> n");
21     A localA;
22     static B localB;
23     printf("foo()    <----------n");
24     return 0;
25 }
26 int main(int argc, char** argv)
27 {
28     printf("main()    ----------> n");
29     foo();
30     foo();
31     printf("nmain()    <---------- n");
32     return 0;
33 }

执行结果：

(二)通过new操作符创建对象。

这种情况比较简答，但容易发生内存泄漏。

1 #include <stdio.h>
 2 #include <stdlib.h>
 3 
 4 class A{
 5 public:
 6     A(){printf("A created. n");}
 7     ~A(){printf("A destroyed. n");}
 8 };
 9 
10 A* createA(void)
11 {
12     A* p = new A();
13     return p;
14 }
15 
16 A* deleteA(A* p)
17 {
18     delete p;
19 }
20 int main(int argc, char** argv)
21 {
22     A* pA = createA();    //第一个对象被创建
23     pA = createA();        //第二个对象被创建
24     deleteA(pA);        //只销毁了第二个对象，第一个对象会一直存在知道程序退出。
25     return 0;
26 }

(三)通过实现创建对象

一般指一些隐藏的中间临时变量的创建和销毁。这些临时对象一般是通过拷贝构造函数创建的。

1 #include <stdio.h>
 2 #include <stdlib.h>
 3 
 4 class A{
 5 public:
 6     A(){printf("A created. n");}
 7     ~A(){printf("A destroyed. n");}
 8     A(A& a){printf("A created with copyn");}
 9 };
10 
11 A foo(A a)
12 {
13     A b;
14     return b;
15 }
16 int main(int argc, char** argv)
17 {
18     A a;
19     a = foo(a);
20     return 0;
21 }

执行结果：

共有四个对象被创建，多出来两个临时对象。只有两个临时对象，似乎不是大问题。但如果foo()是在一个循环内被调用，那将会有更多的对象被创建和销毁。如果这些对象在构造时需要分配很多资源，如内存等，就会造成资源在短时间内频繁的分配和释放（假设资源在析构时能正确的释放），甚至有可能造成大量的内存泄漏（假设析构是没有被正确的释放）。

当一个派生类实例化一个对象时，先回构造一个父类对象。同样在销毁一个派生类对象时，要首先销毁其父类对象。这个父类对象是一个隐含的对象，其生命周期和派生类对象绑定在一起。如果构造父类对象开销很大，会造成所有子类的构造都有很大的开销。

原文链接: https://www.cnblogs.com/kkkwar/archive/2012/04/22/2465041.html

欢迎关注

微信关注下方公众号，第一时间获取干货硬货；公众号内回复【pdf】免费获取数百本计算机经典书籍