大家好，今天再次写c++的文章，首先给各位网友说明一下这段时间为啥都是写c++的文章，没有Linux的文章；原因是这样的，自己立了一个flag，八月份把c++的基本语法全部过完（目前完成三分之一），所以文章过程中我写的可能没有很详细的解释一些概念；所以文章中有不理解的地方，可以私聊我，我会尽力解答好。同时昨天遇到一位刚高考完的网友，人家都这么努力学习，你还打酱油吗？

( ^, h  b4 ^( c! ~" V8 }
. y( z; M  d1 d7 |; y0 B

一、对象的析构顺序：

在上一篇文章里面，已经介绍过对象的构造顺序，既然有对象的产生，那么就会有对象的消亡；换句话说，有资源的分配，最终系统就要收回这些分配出去的资源。所以也就有了对象的析构顺序用法了。下面我们来看一下对象析构顺序的分类,不过这里我们先来看构造对象调用构造函数的来引出对象析构的顺序：

(1)单个对象创建时构造函数的调用顺序：

• 调用父类的构造过程（这个概念暂时还没学，先不用管）

• 调用成员变量的构造函数（调用顺序与声明顺序相同）

• 调用类自身的构造函数

  
  ! k  h5 F/ x1 }; t: w& S2 `% f  R

引出：析构函数与对应的构造函数的调用顺序相反，也就是对象构造与对象析构（消亡）的顺序相反。

(2)代码演示：

1. <font style="background-color:rgb(255, 255, 255)"><font face="Tahoma"><font color="black">
   
2. #include <stdio.h>
   
3. 
   3 f% M) X4 W$ Y( R! i5 l5 l
4. class Test
   . z1 G2 D4 s* O7 U
5. {
   
6.   const char * i;
   & f! {; E+ E- _( H
7.   public:
   
8.      Test(const char *s)
   
9.      {
   ( L% w' m# g* s- q7 R3 a; Z! l
10.         printf("Test(const char *s)  is %s\n",s);
    
11.         i=s;
    
12.      }
    
13.      ~Test()
    ; B# j" Q. ]2 ^! v/ k
14.      {
    + g. d# I  }. o, ~
15.           printf("~Test() is %s\n",i);
    ( Y/ Q$ H" A: z5 S- r7 c9 F
16.      }
    4 [$ ]( I! `0 b3 [" q
17. };
    / t! n4 e) V% @' z
18. 
    " `5 ?; u& }) ~* l
19. class Test2
    
20. {
    
21.     Test mA;
    
22.     Test mB;
    - Q( T) o/ x) w) `/ N3 e
23. public:
    
24.     Test2():mB("mB"),mA("mA")
    
25.         {
    
26.            printf("Test2()\n");
    
27.         }
    
28.     ~Test2()
    
29.     {
    
30.         printf("~Test2()\n");
    9 S  U( C8 A6 g' n7 @" M
31.     }
    
32. };
    3 |+ b* e! C8 S8 u. q; n
33. 
    + W, [' ^' x: m) z; K4 r' D: S
34. Test gA("gA");
    
35. 
    
36. int main()
    
37. {
    / g+ B# k0 F* F# r  k3 V9 a+ u
38.     Test2 t;
    % `0 b7 A1 r4 P1 B. k
39. 
    3 \( s5 b9 L, B+ p% Y8 ~6 n2 ?
40.     return 0;
    ; s6 n0 J# n  T, T" N+ S, b& }6 o
41. }
    : L- v2 v  I. I- J% U1 P
42. </font></font></font>
    + N5 }( |, O5 J. A0 ]4 r

复制代码

演示结果：

1. <font style="background-color:rgb(255, 255, 255)"><font face="Tahoma"><font color="black">
   
2. Test(const char *s)  is gA
   / N! E8 ^/ b0 {" t
3. Test(const char *s)  is mA
   
4. Test(const char *s)  is mB
   
5. Test2()
   * a7 G$ k+ D. }* R7 w
6. ~Test2()
   1 j5 m& C  z1 Y* _& X5 ^
7. ~Test() is mB
   - D6 b6 t1 N' p& t2 X
8. ~Test() is mA
   # J3 E: u0 l/ R7 W7 H- E
9. ~Test() is gA</font></font></font>
   

复制代码

说明：从运行结果，我们可以看到先触发全局对象的构造函数，然后是触发初类Test2里面的mA和mB对象的构造函数，最后 触发局部对象的构造函数，然后进行析构，我们可以看到，析构顺序完全和构造顺序相反。非常类似于栈的操作规则，栈是先入栈，却是最后出栈。

二、const关键字可以修饰类的对象嘛？

1、这个问题答案肯定是可以修饰的，为啥这么说呢？不知大家还是记得c语言里面的struct关键字不，在之前的文章里面也学习过，使用struct关键字也可以来构造类名，只不过他的所有成员都是公开的（public）；换句大家好理解的话，就是结构体，那么在c语言里面，const关键字肯定是可以修饰结构体变量的，当然在c++里面肯定也是可以的，c++不是取代c语言的，而是对c语言进行扩展着，并且兼容c语言的。不过const修饰的对象有啥特性呢？

const修饰的对象特性：

• const修饰的对象为只读对象

• 只读对象的成员变量不允许被改变

• 只读对象是编译阶段的概念，运行时无效

  
  

代码示例：

1. <font style="background-color:rgb(255, 255, 255)"><font face="Tahoma"><font color="black">
   0 ]6 Y! x- H2 ]2 e$ e# h
2. #include <stdio.h>
   
3. 
   
4. class Test
   
5. {
   
6.     int mi;
   ( E/ V8 O/ g; m3 E
7. public:
   
8.     int mj;
   , P( a3 b2 |! m* e+ F! A6 u
9.     Test(int i);
   & C  o* R1 K3 ^/ k3 [3 V& g- [# L
10.     Test(const Test& t);
    
11.     int getMi();
      \) p3 t2 h! u" t1 H
12. };
    2 L5 K1 Z: E; q6 ~) }* Q6 P
13. 
    - w4 E+ V5 B" e) @6 E( @
14. Test::Test(int i)
    7 u& H: a" c+ Q0 z, k* f1 ^7 S. }
15. {
      M7 g" V6 {; V+ k
16.     mi = i;
    
17. }
    
18. 
    ( r: U/ A+ q; y5 x& n; C  e
19. Test::Test(const Test& t)
    1 l$ J# ?& c' W5 X' r. C4 v: B
20. {
    
21. 
    
22. }
    + J" y" j: Q& G3 Q8 `* }
23. 
    
24. int Test::getMi()
    
25. {
    " t3 _- Q  D- u5 j# t
26.     return mi;
    4 E0 d! l% p3 ]; L" T3 Y& |
27. }
    * E7 P! @! b/ i* W% X3 f! J
28. 
    $ b/ b6 o/ d' F- L, {% T
29. int main()
    
30. {
    
31. 
    ( x1 T9 N5 u8 v% v$ J( @
32. 
    9 x- Z6 V7 ]1 Y2 p$ L- J0 W
33.         const Test t1(1);
    
34. 
    
35.         t1.mj = 100;
    
36.         printf("the t1.mj is %d\n",t1.mj);
    
37. 
    
38.         return 0;
    9 p; s2 l/ @/ q" u
39. }</font></font></font>
    3 u* ?1 s+ ?; n$ N* f

复制代码

5 q) \3 _8 c) H. h

运行结果：

1. 
   
2. test.cpp: In function ‘int main()’:
   1 [* b8 ~4 y6 t' H$ f6 r
3. test.cpp:34:10: error: assignment of member ‘Test::mj’ in read-only object
   3 r6 Z- k( k3 b7 F
4.   t1.mj = 100;

复制代码

' x8 t4 Z+ ^$ \9 v

分析：我们可以看出public里面的属性mj是不能修改的，为只读的，因为类对象被const修饰了。

2、const成员函数：

其实以前在写初始化列表的文章之前，以前提到过const修饰的成员属性（不过这个属性是私密的），我们只能用初始化列表对其进行初始化；提这个的原因是；也算是复习一下；同时说的直白一点，咋们刚才讲解完了const修饰的对象，同时用该对象访问的类成员属性是不能修改的；现在我们当然会想到const成员函数了，一环扣一环嘛（我不说，你看到这里也会有好奇心！）；下面我们来看一下const成员函数的定义和规则：

(1)定义：

1. <font style="background-color:rgb(255, 255, 255)"><font face="Tahoma"><font color="black">
   
2. Type ClassName::function(Type p)const
   1 a1 d% j  w+ [3 s! E- m6 `
3. 
   2 s* l9 m. b9 @
4. 类中的函数声明与实际函数定义中都必须带const关键字，注意const是函数结尾</font></font></font>
   

复制代码

(2)规则：

const对象只能调用const的成员函数，不能调用普通的成员函数，例如：

1. <font style="background-color:rgb(255, 255, 255)"><font face="Tahoma"><font color="black">
   
2. #include <stdio.h>
   $ ^2 V# j, O# l- N
3. 
   . }- ]3 U4 o# p/ J6 H
4. class Test
   # X9 F5 c/ s7 k6 i9 {$ k2 L4 a
5. {
   2 Z$ |  l4 S% b- ^2 o
6.     int mi;
   
7. public:
   - J! g6 j3 H5 M0 O; W' x
8.     int mj;
   
9.     Test(int i);
   
10.     Test(const Test& t);
    
11.     int getMi();
    
12. };
    ) R' Q; f. U2 ~% ~4 v$ l6 O
13. 
    * m) t9 `% [  f) M3 J8 i1 }
14. Test::Test(int i)
    
15. {
    
16.     mi = i;
    $ y7 h7 i; V8 w5 U7 f
17. }
    . G2 s/ v- i) P" L3 ~
18. 
    
19. Test::Test(const Test& t)
    
20. {
    8 e5 j, |5 k' E$ m, }
21. 
    
22. }
    8 A/ g& Y3 y/ E' M
23. 
    
24. int Test::getMi()
    $ X5 l3 O" k! L" d
25. {
    
26.     return mi;
    
27. }
    
28. 
    4 O4 N, a" _2 J5 M0 {. V
29. int main()
    6 V4 N7 ~* A1 B: s4 M, h
30. {
    
31. 
    
32. 
    * H) C- u: Z- |7 ^9 ~: L: L
33.         const Test t1(1);
    & [1 B, Y  r, m- V; _% k
34. 
    
35.         printf("the mi is %d\n",t1.getMi());
    
36. 
    
37.         return 0;
    $ h9 ~4 T6 O: P, ~4 C8 `
38. }</font></font></font>
    

复制代码

演示结果：

1. 
   8 B' x8 Q5 @# ]# I/ a9 _) ]
2. test.cpp: In function ‘int main()’:
   
3. test.cpp:34:42: error: passing ‘const Test’ as ‘this’ argument discards qualifiers [-fpermissive]
   
4.          printf("the mi is %d\n",t1.getMi());
   
5.                                           ^
   
6. test.cpp:23:6: note:   in call to ‘int Test::getMi()’
   
7.   int Test::getMi()
   7 }: ^! X% w) c- P
8.       ^~~~

复制代码

) I# l+ m$ s0 O# Z. R( l. ?

我们可以看到const修饰的类对象调用普通成员函数报错，现在我们把普通成员函数getMi()改成const成员函数：

1. 
   
2. #include <stdio.h>
   
3. 
   " Y4 R: T" J+ l$ e
4. class Test
   / b. t2 d* D7 M
5. {
   
6.     int mi;
   
7. public:
   
8.     int mj;
   
9.     Test(int i);
   
10.     Test(const Test& t);
    
11.     int getMi() const;
    ) @9 y  u( a0 t: m3 e& q5 ^
12. };
    
13. 
    
14. Test::Test(int i)
    ' {6 c8 |" |# j7 r9 J; M
15. {
    0 I, b( l0 N8 q1 O& M: J1 q* R
16.     mi = i;
    - K, {" g) \1 w; |- s8 y5 F! t& g
17. }
    
18. 
    ) w( u: A$ a0 N9 i
19. Test::Test(const Test& t)
    3 O1 e1 D) }+ `1 R& h& `9 l0 q
20. {
    ) @0 O2 |3 H( |0 ^, S
21. 
    
22. }
    ' b  q! q2 W+ O+ O) a
23. 
    
24. int Test::getMi() const
    
25. {
    " i' _6 y9 I* L: y
26.     return mi;
    - y) u9 @% }5 A8 w* Y, N% ^' w
27. }
    
28. 
    
29. int main()
    
30. {
    
31. 
    0 v. Q" e- o1 H: K7 Q
32. 
    
33.         const Test t1(1);
    + w1 o& K. Q2 \3 c/ ?
34. 
    , K% T  {9 `6 E: O5 p# v" b
35.         printf("the mi is %d\n",t1.getMi());
    $ j! E- ~' s2 d
36. 
    : f& r$ a3 s" Y9 X; L9 W
37.         return 0;
    
38. }
    / b0 N3 a$ n# P

复制代码

: o$ e6 l/ O) {( m

这样的话就可以编译通过了，哈哈。

const成员函数不能直接修改成员变量的值：

1. 
   7 m0 M2 L* H. Q# {+ A3 A2 T( F
2. #include <stdio.h>
   
3. 
   
4. class Test
   * f' {. b% h7 D" U: _3 {
5. {
   7 Z6 T% X. ]0 m. d, q
6.     int mi;
   
7. public:
   5 Q1 `, G% |3 t% A# I
8.     int mj;
   
9.     Test(int i);
   ; [: N2 `  L/ I5 ]
10.     Test(const Test& t);
    
11.     int getMi() const;
    9 P' s& r* Z2 F
12. };
    $ C4 |: ^4 X" y  E  c$ b& l, d) Y8 F% }# M
13. 
    
14. Test::Test(int i)
    
15. {
    
16.     mi = i;
    1 O. ^  J2 b; Q7 ~' Q  C
17. }
    : x; v  l% z; P* ^6 W4 |' P7 ?
18. 
    
19. Test::Test(const Test& t)
    
20. {
    
21. 
    * O9 r( T7 I# e9 s' I
22. }
    $ U  o0 S0 v' U
23. 
    3 P5 m' h' m- D4 K. D6 c9 P2 }& ?; l
24. int Test::getMi() const
    
25. {
    
26.     mj = 89;
    
27.     return mi;
    " d, I3 R; X( I! c
28. }
    3 o. T' r) F% R( x. I9 h1 m
29. 
    % c) J  k' r% _, ^0 ^/ R
30. int main()
    8 E% M( e# |2 H. X! E1 f' F. Y. W! m
31. {
    . F3 l' i( b2 q# U5 R* x% k5 C
32. 
    
33. 
    * e6 |" ~) l4 F" G4 o: Z
34.         const Test t1(1);
    
35. 
    
36.         printf("the mi is %d\n",t1.getMi());
    
37. 
    5 `; Y! E% T- E1 n. S
38.         return 0;
    
39. }
    

复制代码

& T. B% a" U$ T! O

运行结果：

1. 
   
2. root@txp-virtual-machine:/home/txp# g++ test.cpp
   ) F. L2 a  D; t
3. test.cpp: In member function ‘int Test::getMi() const’:
   
4. test.cpp:25:10: error: assignment of member ‘Test::mj’ in read-only object
   
5.      mj = 89;

复制代码

  U3 ?; m* B- m. W  |: E! s% b

const 成员函数中只能调用 const 成员函数：

1. <font style="background-color:rgb(255, 255, 255)"><font face="Tahoma"><font color="black">
     Z- Z5 e, D6 C! z
2. #include <stdio.h>
   
3. 
   
4. class Test
   ) p' S9 `/ B: R
5. {
   - s$ C% m8 O0 H+ Y4 p8 z
6.     int mi;
   # @# c5 R8 n# r# \! A) r3 |, y
7. public:
   
8.     int mj;
   $ }6 O7 Q' p2 i* }  _
9.     Test(int i);
   4 j- c8 t* }! D2 W
10.     Test(const Test& t);
    
11.     int getMi() const;
    
12.     int getMj() const;
    
13. };
    $ U' a5 M# x) |
14. 
    
15. Test::Test(int i)
    ; s$ \$ Z; n7 f- b7 v
16. {
    
17.     mi = i;
    9 ?9 g( f3 u8 b7 v
18. }
    
19. 
      \& q- D& E( c, b
20. Test::Test(const Test& t)
    
21. {
    , T' j  E" Q& z: o
22. 
    
23. }
    
24. 
    
25. int Test::getMj() const
    & D- l+ I# y: d+ m) s% B
26. {
    
27.     return mj;
    5 H; U4 @+ M* Y9 Q. v
28. }
    
29. int Test::getMi() const
    & ~$ R- E2 w8 I6 p/ J+ h4 |6 o
30. {
    
31.     getMj();
    & g  V  c* y7 O' V( Z+ O- n
32.     return mi;
    
33. }
    
34. 
    : g1 V9 R+ e# \4 [! T
35. int main()
    ! Z+ f* L/ L- Q; h
36. {
    
37. 
    ( c! o+ Q7 G; v6 {, U! q
38. 
    & ~2 W0 j# G% C
39.         const Test t1(1);
    
40. 
    
41.         printf("the mi is %d\n",t1.getMi());
    2 S# P8 ?9 m1 a, I* i! t" z
42. 
    ) |: h- J" d4 R% _: P8 Q
43.         return 0;
    
44. }</font></font></font>
    % u* v0 e0 L6 N

复制代码

3、搞清楚成员函数和成员变量是否都是隶属于具体对象

• 从面向对象的角度看，对象由属性（成员变量）和方法（成员函数）构成

• 从程序运行的角度来看，对象由数据和函数构成，而数据可以位于栈、堆、全局数据区；而函数只能位于代码段，而代码段是只读的，在程序运行过程中是不可以被改变的，而对于数据来说，他们处于栈、堆，是可以动态的创建和动态的删除；

  
  

4、this指针

不知大家是否注意到在拷贝构造函数里面的这条语句，参数里面是引用，那么t也相当于是一个对象，所以会有t.mi这样的写法，这里要明白：

1. 
   
2. Test(const Test& t)
   
3. {
   6 N9 Q, o% l* Y% i7 n
4.    mi = t.mi;
   % `9 E' F" G$ F* \
5.                
   
6. }

复制代码

所以这里我就引出了this指针，他表示方法中的隐藏参数代指当前对象，为了说明这个，下面我们来看一个代码示例：

1. <font style="background-color:rgb(255, 255, 255)"><font face="Tahoma"><font color="black">
   ) _' m3 h8 b7 r. T/ b, e4 v
2. #include <stdio.h>
   
3. 
   
4. class Test
   
5. {
   
6.     int mi;
   ' R# T$ X& A8 q# p; O) z- i& |
7. public:
   
8.     int mj;
   5 p4 S* A7 }+ o7 q5 [
9.     Test(int i);
   
10.     Test(const Test& t);
    
11.     int getMi();
    & O$ |4 ?) ^* g8 L- u% c& U
12.     void print();
    
13. };
    
14. 
    
15. Test::Test(int i)
    1 N1 P5 d' i7 g- J/ \/ M& X
16. {
    
17.     mi = i;
    
18. }
    / r8 s" ^2 m2 p% b
19. 
    
20. Test::Test(const Test& t)
      J* O5 X! C( y
21. {
    
22.     mi = t.mi;
    * A. I4 m, h5 I/ m
23. }
    ) F6 N. I: H8 s* g8 X" Q. @2 S
24.    
    + n/ A& ~. e9 ~# o
25. int Test::getMi()
    
26. {
    ! A) \& e% I0 W& I" ^
27.     return mi;
    
28. }
    
29. 
    8 B  S' ?  Z, a2 K) K
30. void Test::print()
    . R8 @; m& n$ M6 U
31. {
    / {$ @& e  D; V1 c1 L
32.     printf("this = %p\n", this);
    
33. }
    
34. 
    
35. int main()
    
36. {
    & P& [$ \) `8 N4 j' ]8 f
37.     Test t1(1);
    5 v' J6 c" P) e
38.     Test t2(2);
    
39.     Test t3(3);
    & f. O8 o/ D8 I; k4 J" l
40.    
    
41.     printf("t1.getMi() = %d\n", t1.getMi());
    2 W. [% k4 A8 \: [
42.     printf("&t1 = %p\n", &t1);
    
43.     t1.print();
    3 g' x/ K/ ]* y
44.    
    
45.     printf("t2.getMi() = %d\n", t2.getMi());
    
46.     printf("&t2 = %p\n", &t2);
    " R' y; `# K0 u  X. ?
47.     t2.print();
    4 }- u+ m% l" R. E% v
48.    
    
49.     printf("t3.getMi() = %d\n", t3.getMi());
    $ j* D# Z) n2 M
50.     printf("&t3 = %p\n", &t3);
    + P) U% f  }5 p" ^! G
51.     t3.print();
    
52.    
    . u; n' ~6 t5 q& e* m
53.     return 0;
    , A) e$ l8 f: T6 S5 G
54. }</font></font></font>
    ' n0 H) H- e; w/ S- w5 i6 t# g: N9 t3 G' [

复制代码

输出结果：

1. <font style="background-color:rgb(255, 255, 255)"><font face="Tahoma"><font color="black">
   
2. root@txp-virtual-machine:/home/txp# ./a.out
   
3. t1.getMi() = 1
   
4. &t1 = 0x7ffec3f5e750
   
5. this = 0x7ffec3f5e750
   4 B0 G* Q0 M" J  X* D& o/ Y
6. t2.getMi() = 2
   ) p, c( t% @& w5 {  s
7. &t2 = 0x7ffec3f5e758
   ! }3 N: K4 F6 T. F6 A$ a4 _$ Q
8. this = 0x7ffec3f5e758
   
9. t3.getMi() = 3
     Z. t5 A: U* r; F1 p& j  C
10. &t3 = 0x7ffec3f5e760
    ( k  I* y+ n" j% Z' S4 H/ B+ n
11. this = 0x7ffec3f5e760</font></font></font>
    9 R; b7 P% U& ]/ Z

复制代码

分析：

• 在类的成员函数当中，有一个隐含的参数，就是我们刚才说的this指针，它的值就是调用这个函数所对应的对象的地址，说白了，this指针指向当前对象。

• 每一个对象都有一套自己的成员变量，对象和对象之间的成员变量是独立的、不同的；但是每一个对象都共享一个类的成员函数

  
  ; t3 q! i3 O# }2 f& o

三、总结：

• 对象的析构顺序与构造顺序相反

• const 关键字能够修饰对象，得到只读对象

• 只读对象只能调用 const 成员函数

• 所有对象共享类的成员函数

• 隐藏的 this 指针用于表示当前对象

  
  

好了，今天的分享就到这里，如果文章中有错误或者不理解的地方，可以交流互动，一起进步。

4 s" S+ d9 B, B' J9 v5 L