C++中的析构顺序和cosnt对象

 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 }

 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);  // 实际工程开发中，并不一定每一个成员函数都是 const 的，这就意味着很少使用 const 对象，所以 一般情况都不用定义 const 成员函数；
36     
37     t1.mj = 1000;  // 不能给只读变量 mj 赋值；const 修饰对象后，得到只读对象，其对应的成员变量值是不可以被改变的；只读变量：编译阶段不能出现在赋值符号左边，运行时能够改变；
38                    
39     printf("t.getMi() = %d\n", t.getMi());  // 编译器显示 getMi() 是不可以被调用的，因为这个时候 t 是只读对象，但是 getMi() 这个时候不是 const 函数，加上后则可以了；
40     
41     return 0;
42 }

 1 #include <stdio.h>
 2 
 3 class Test
 4 {
 5     int mi;
 6 public:
 7     int mj;
 8     Test(int i);
 9     Test(const Test& t);
10     int getMi();
11     void print();  // 加这个函数是为了证明所有对象共用一套成员函数；
12 };
13 
14 Test::Test(int i)
15 {
16     mi = i;
17 }
18 
19 Test::Test(const Test& t)
20 {
21     mi = t.mi;  // 成员函数可以直接访问成员变量，因此拷贝构造函数这个特殊的成员函数就可以直接访问对象的成员变量，所以这里直接访问了 t 这个引用所指代的对象的成员变量是完全合法的；成员函数只有一套，它能直接访问任何所属类对象的成员变量，当然被调用时只传递一个对象的地址；
22                 
23 }
24     
25 int Test::getMi()
26 {
27     return mi;
28 }
29 
30 void Test::print()
31 {
32     printf("this = %p\n", this);
33 }
34 
35 int main()
36 {
37     Test t1(1);
38     Test t2(2);
39     Test t3(3);
40     
41     printf("t1.getMi() = %d\n", t1.getMi());  // 1
42     printf("&t1 = %p\n", &t1);  // t1 的地址
43     t1.print();  // t1 的地址
44     
45     printf("t2.getMi() = %d\n", t2.getMi());  // 2
46     printf("&t2 = %p\n", &t2);  // t2 的地址
47     t2.print();  // t2 的地址
48     
49     printf("t3.getMi() = %d\n", t3.getMi());  // 3
50     printf("&t3 = %p\n", &t3);  // t3 的地址
51     t3.print();  // t3 的地址
52     
53     return 0;
54 }