TOP

C++中的析构顺序和cosnt对象(一)
2019-05-23 14:32:00 】 浏览:73
Tags:顺序 cosnt 对象

1,当程序中存在多个对象的时候,如何确定这些对象的析构顺序?

 

2,单个对象创建时构造函数的调用顺序(工程经验总结):

    1,调用父类的构造过程;

    2,调用成员变量的构造函数(调用顺序与声明顺序相同);

       1,某个类的成员是其它类的对象;

    3,调用类自身的构造函数;

       1,析构函数与对应构造函数的调用顺序相反;

   

3,多个对象析构时:

    1,构造顺序与析构顺序相反;

   

4,构造与析构顺序实例分析:

 1 #include <stdio.h>
 2 
 3 class Member
 4 {
 5     const char* ms;
 6     
 7 public:
 8     Member(const char* s)
 9     {
10         printf("Member(const char* s): %s\n", s);
11         
12         ms = s;
13     }
14     
15     ~Member()
16     {
17         printf("~Member(): %s\n", ms);
18     }
19 };
20 
21 class Test
22 {
23     Member mA;
24     Member mB;
25     
26 public:
27     Test() : mB("mB"), mA("mA")
28     {
29         printf("Test()\n");
30     }
31     
32     ~Test()
33     {
34         printf("~Test()\n");
35     }
36 };
37 
38 Member gA("gA");
39 
40 int main()
41 {
42     Test t;  // gA
43              // mA
44              // mB
45              // Test()
46              // ...
47              //~Test()
48              // mB
49              // mA
50              // gA
51     
52     return 0;
53 }

   

5,对于栈对象和全局对象,类似于入栈与出栈的顺序,最后构造的对象最先析构;堆对象的析构发生在使用 delete 的时候,与 delete 的顺序相关;

  

6,const 关键字能否修饰类的对象?如果可以,有什么特性?

    1,const 关键字能够修饰对象;

       1,类也是用户自定义的数据类型,类是从 struct 进化而得到的一个全新关键字,struct 专门用来定义结构体,其定义的结构体在 C 语言中依旧是变量,既然是变量,就可以被 cosnt 所修饰;

       2,对应的,对象在某种角度也是变量,所以也可以被 const 修饰;

    2,const 修饰的对象为只读对象;

       1,这是唯一的可能性;

    3,只读对象的成员变量不允许被改变;

       1,对象就是由一系列的成员变量构成的,对象已经是只读的了,也就意味着成员变量是不允许被改变的;

    4,只读对象是编译阶段的概念,运行时无效;

       1,只读对象起始还是可以被改变的;

   

7,C++ 中的 const 成员函数:

    1,const 对象只能调用 const 的员函数;

       1,因为 const 对象的 this 指针是底层常量,不能拷贝给非 const 的成员函数的 this 指针,因为后者的 this 是变量,这会改变 const *this 的属性,造成其指向的对象会被改变;

    2,const 成员函数中只能调用 const 成员函数;

       1,底层 const 指针不能拷贝给非 const 指针;

    3,const 成员函数中不能直接改写成员变量的值;

       1,const 成员函数只能被 const 对象调用,而此时其成员函数也底层 const 的,不能修改底层 const 指针指向的变量;

    4,const 成员函数特殊的意义是被只读对象调用;

       1,底层 const 指针不能拷贝给非 const 指针;

   

8,const 成员函数的定义:

    1,Type ClassName::function(Type p) const

       1,声明之后,函数体之前;

    2,类中的函数声明与实际函数定义中都必须带 const 关键字;

   

9,类的 const 函数初探编程实验:

 1 #include <stdio.h>
 2 
 3 class Test
 4 {
 5     int mi;
 6 public:
 7     int mj;
 8 
 9     Test(int i);
10     Test(const Test& t);
11     int getMi() const;
12 };
13 
14 Test::Test(int i)
15 {
16     mi = i;
17 }
18 
19 Test::Test(const Test& t)
20 {
21     // mi = t.getMi(); getMi() 非常函时,t 是对象的常引用,t 这个对象代表的引用代表只读对象,只能调用 const 函数;
22     mi = t.mi;  // 这个时候可以,mi 是私有的,能够通过点操作符来访问吗?不是说只有对象自己的成员函数才可以访问自己的成员变量吗?这就引出了本文10中的问题;
23 }
24     
25 int Test::getMi() const 
26 {
27     // mi = 2; 这里出错,不能够修饰 mi 的值;
28     return mi;
29 }
30 
31 int main()
32 {
33     Test t(1);
34     
35     const Test t1(1);  // 实际工程开发中,并不一定每一个成员函数  
		
C++中的析构顺序和cosnt对象(一) https://www.cppentry.com/bencandy.php?fid=49&id=224335

首页 上一页 1 2 3 下一页 尾页 1/3/3
】【打印繁体】【投稿】【收藏】 【推荐】【举报】【评论】 【关闭】 【返回顶部
上一篇C++中的字符串类 下一篇博弈论之SG函数