你的浏览器版本过低,可能导致网站不能正常访问!
为了你能正常使用网站功能,请使用这些浏览器。

c++——对象构造顺序和销毁

[复制链接]
gaosmile 发布时间:2020-8-4 23:01
一、对象的构造顺序:
1、对于局部对象:
当程序执行流到达对象的定义语句时进行构造。下面还是用代码来解析这句话:
#include <stdio.h>& f# G3 L, }5 S$ W1 R

( o7 j: q9 |( Y+ D, Kclass Test; H7 n3 t5 V6 g4 A
{; H$ G8 ]/ o: z+ Q/ L
     private:
- M: b9 g/ t* |* Y. {* M- y3 n- Q        int mi;% s- T2 e" H4 V* I7 F8 S$ y- L' Z
     public:
( t/ ?; j9 a. m$ O        Test(int i)% f! |, }$ f  x0 }9 S- t! U
        {
7 D! g5 n) S6 @            mi=i;
) O7 {1 x7 g9 l. w, R: b1 ^. Z" D            printf("Test(int i) is %d\n",mi);
# w) B$ \3 Z0 Y' c/ L/ O+ g; C        }6 p( C/ c7 D7 u4 b
        Test(const Test& obj)) X$ q+ T8 x! D; u. {, w  o8 B
        {
: F0 U- b0 O0 }, G3 O( z, `9 w            mi=obj.mi;
9 C! Y' S! u2 K9 M            printf("Test(const Test&) obj is %d\n",mi);, q- s1 m2 d& c0 l6 G, d0 |( K6 w; z; Q
        }- ]% [; e- x6 l9 P/ d: h
};
$ G$ ~! G4 n3 w3 n8 gint main()1 m, c4 w: D: r8 t  |- x
{3 z2 h9 S5 R/ V+ m! W  ]% c) m5 J
2 M' O4 ]% G( V9 R$ G/ l2 r: M3 D
    int i = 0 ;
2 {: b: Y8 N: m- F     Test a1 =i;//Test(int i):0
2 [' W( K+ P) A. F6 I( \     while(i<3)
# X. R- U5 L. i7 N3 r) q7 [     {/ F( [* l9 z0 s: I6 ^
        Test a2 = ++i;//Test(int i):1,2,3
0 {+ a9 A3 G3 }4 ?- ]9 Q& s     }
' f2 ]+ P+ ?. U) S     if(i<4)
2 `: \9 v! F; i  E     {
5 ]; a6 d0 l8 d        Test a = a1; //Test(const Test& obj is :0
* ]$ j: ]/ U$ g- p$ r- {. g     }% i# ~8 H! ?/ E) `6 Y
     else  V0 b( |# u2 g% [9 p
     {, W( A& x: B5 |% S2 m  C
        Test a(100);: H! n3 h# L, ]9 r8 J! @

4 J% a3 w: D0 c6 R     }
$ B# p+ R  Z7 s# t     return 0;
7 n6 T) _! y& Z: ?}
/ ^8 c" a# D: [

7 H0 q& o! o; g# l9 l2 m* v* p5 h: x
输出结果:
Test(int i) is 0
9 v4 v/ H2 F: X8 f0 e+ L: M. h# i6 bTest(int i) is 1: ~6 D1 f% e) {
Test(int i) is 2- a  h1 D1 c' S: J, i2 R4 W
Test(int i) is 3
2 `. ~" J" E4 o# E( z; S. aTest(const Test& obj) is 0+ D! z" o  l9 _0 l1 ?  t  t9 m- g

: N" b% Z1 ], K! i" g1 s, C' ~
这里我们可以看出当程序流执行到相应的构造对象的那条执行语句时,就会调用构造函数(或者拷贝构造函数)。goto语句想必大家不陌生,但是都害怕这玩意,下面我们加入goto语句看看会产生什么现象:
#include <stdio.h>9 d  A1 C/ D. f' z, o" O% E
class Test{$ O! ^' s/ P9 ^  \
private:
  K( Y+ {# d, A$ i) y" w1 C    int mi;. Y2 q/ L% G% h6 o/ i, c
public:; _& h& l0 ?$ ?* m: [3 f
    Test(int i)) m3 ~. v8 y6 S! z* K
   {) ?' _$ p9 x) N2 B& H& x- U
        mi=i;+ Q! S* W6 @5 ]" m3 G
        printf("Test(int i) is %d\n",mi);, }  [9 e# Z% a# Y- d' o7 t
) o* F+ r. N3 X4 L% v# O
    }
* M8 C- ^2 p; u    Test(const Test& obj)3 Q/ q* k0 f: M) K
    {: m9 p5 I4 H' V% u4 X
       mi=obj.mi;- |) a8 n5 s. k% ?6 V( |$ y1 D
       printf("Test(const Test& obj is %d\n",mi);( a8 o% }1 q! @8 v3 I
! f8 t3 \- t+ ]7 M" i! r$ C. b
    }# ?# R7 r: F4 ?$ `

" l$ I- G. Z7 I+ L5 r- L};7 C4 x9 ~6 L  F* N
int main()! r, P& R+ q0 L
{. T1 z% X4 K0 G
   int i = 0;  //Test(int i) :0+ q  P+ t) G/ j9 ^7 K
   Test a1 = i;
, D* n* ~9 J  h& Y5 C   while( i <3); L& @- w* P/ ]$ S. |3 ]) `
   {& j2 u9 n  Z3 q
        Test a2 = ++i;  //Test(int i) :1,2,3
8 _6 j2 Q; a3 L0 t7 q    }$ \( a$ _  X% g# [% _" ~/ A
goto end;
2 w% Y/ P: y  |0 b1 c4 n   if(i <4)
: h) b3 n- k/ l5 A$ ?6 d$ x: h    {
+ P% \+ H! g5 [& i- i       Test a = a1;//Test(const Test&) obj is :0. M$ I8 V/ a; |
  }( L5 N9 l5 P6 |
    else
( d1 M. P7 _0 Q" v    {
0 R' i; {  i- I+ b       Test a(100);3 u0 Q% I8 R' @, L6 }9 q7 v. I
     }6 ?* B) K, M+ u1 I  Y9 j
end:
# Y" Q. z  d0 b( Q& Q. F, P5 x) I    return 0;; z5 W- v4 E% B9 h, d) M
}" ~' X$ w$ U) B% Z7 v$ K1 u4 t( Y

2 m5 b+ g/ ]9 r2 D) B2 s8 G+ Q  z
输出结果:
Test(int i) is 0
% r$ O- m& y+ M1 jTest(int i) is 1
! s) A- {, u. q) YTest(int i) is 2. s# N; ?* }/ G7 G
Test(int i) is 3

# E. q2 ^; E! n' }% }
从结果我们可以看出从if那条语句就被跳过了,没有执行到,这里这样写的目的是为了引出,当你使用goto语句,把对象给屏蔽了,后面你不能使用这个对象了,不然程序会出现大问题:
#include <stdio.h>( q$ {- Z  F2 j# g% ]6 w
class Test{
; Z+ X" A. e3 w5 @- P6 mprivate:. g6 [+ r7 m) h+ P( `( p$ i
    int mi;
. B$ m) M5 ?- Gpublic:! [; S3 `1 n0 v
    Test(int i)+ i0 @, J/ O7 J0 }0 I% c$ T
   {7 |4 f& X7 ^% A
        mi=i;
. y) _4 B; {7 X: n1 l, L( I        printf("Test(int i) is %d\n",mi);
9 P3 K5 |% p2 V
; Q. l) |+ U7 k( }6 b1 w, f    }
: i9 i4 q$ L& f    Test(const Test& obj)
6 d2 m: J2 x2 I& T& S3 m9 q    {0 e/ k1 ^% N5 Y' F# H7 D7 K
       mi=obj.mi;' r! B( q4 ?; S4 R* ^: \
       printf("Test(const Test& obj is %d\n",mi);" k% m5 V* h4 s: \2 c0 o
    }, I$ X' d: A. C, x' C
    int getMi()
1 `% i. w# ]3 s1 n  j- P     {
& A) b2 R/ f0 S; h* H4 V         return mi;
  x5 [, `4 `0 `     }
$ Q4 [$ y; {( N( Y' @1 f6 c, }5 s};
7 C6 M3 P4 }& H3 K6 j* q) bint main(), A# n) w, h* a. W7 G6 U
{
% ?. o2 ?* x3 d  q( u( e( P4 i   int i = 0;  //Test(int i) :0
7 s8 l. m; i" h   Test a1 = i;
, `" O- T  E: t) i, _, t/ t   while( i <3)* |  N, G; I/ b/ S. w
   {" p- U% e: ~  e: c
        Test a2 = ++i;  //Test(int i) :1,2,3
) h' E% w- g2 }) c& P    }, }& d- I* h4 @* Q1 J
goto end;
3 t9 D5 A- V2 ^/ U      Test a(100);6 p% e' X- y% ?
end:& `# ?+ R3 y' ^5 O
     printf("a.mi is %d\n",a.getMi());+ m0 {  b- U; H+ G0 ?% S
$ U" o* q; W8 S! ^( [( G
    return 0;( u$ F* z' G+ Z+ h% _4 @
}" L2 z( P+ T3 W0 f1 J9 [/ R& z

* A* Z* J/ w+ @& m; I+ U. t8 |/ j6 w0 `
输出结果:
tt.cpp: In function ‘int main()’:2 C$ f5 c7 z: Z
tt.cpp:32:1: error: jump to label ‘end’ [-fpermissive]
: i. U- C! P0 y: _4 F end:2 |0 i% S6 H2 w' h( o1 L/ ^) K! s
^( N; j3 A1 [/ T( \
tt.cpp:30:6: error:   from here [-fpermissive]
" e& i2 {6 ?, n goto end;
- k  p7 _1 W  u+ V# E      ^
: T% ]+ Q% [, }  Ftt.cpp:31:12: error:   crosses initialization of ‘Test a’; Y8 h; j/ K8 I- T2 ^7 k
       Test a(100);
5 w/ M: R% c3 F, ?            ^) T3 ^' k6 K! q- v0 y  x9 f) P

# Q* x+ O) O% l. ?: v
这里就是上面所说了的,对象被goto语句给屏蔽了,后面就不能使用这个对象来进行操作了。
2、对于堆对象:
  • 当程序执行流到达new语句时创建对象
  • 使用new创建对象将自动触发构造函数的调用

    & e4 H% g* S- n8 X0 K$ k' r
代码演示:
#include <stdio.h>" K8 s8 _- R) s3 H
$ F! V1 V7 T; _/ X
class Test
9 ^2 f) S( C* L  }' I5 Q4 J  @& z{
1 ]9 S: e6 w/ @; H1 W& Z2 o. Xprivate:
& D% l. S& D/ Z- |# R/ z% q    int mi;! a' S4 `+ x1 r3 a! R
public:+ h2 U2 ?* l. z! q  _7 W
    Test(int i)
! I# Z4 O3 _+ j0 W  |- B$ }2 w9 j    {
  K% h5 ?6 x1 K' b/ Y. X1 k        mi = i;  x8 H, ?7 R, J$ B2 H
        printf("Test(int i): %d\n", mi);
: K* j2 X  ^2 p0 c) y) s    }( }' y: ?/ }% r7 K2 I
    Test(const Test& obj)4 G, G7 m. [8 P# D* T$ `
    {4 R: N; l. c1 S
        mi = obj.mi;
* z  T1 [" D5 E3 b! ]        printf("Test(const Test& obj): %d\n", mi);
$ A: f9 n- }" m+ }    }
7 d+ y, f4 P7 A& x# ?* d: @2 q    int getMi()
3 @- N  y/ A# ~+ G    {0 x/ M7 u% \/ Q, ?' P; Z6 J# `
        return mi;* R1 G7 D% m/ Y3 c' S* ]+ @$ ~
    }- W: A/ s! c1 L$ K
};' f1 D+ Z+ h6 O: P) R9 \
/ _1 p1 o) O( O. g) b
int main()+ Q: M( l! G: U
{$ N: H* N8 S/ d0 G6 p3 f
    int i = 0;) o$ ~/ P: a+ o  C7 u& D# F5 c
    Test* a1 = new Test(i); // Test(int i): 0+ u9 p; Q* E0 D) |: a* u$ i
        3 N: x$ T5 s* e& _5 E
    while( ++i < 10 )
0 M- D- K1 v- u7 X+ _        if( i % 2 )( F9 p' {1 V" A. a6 x* a
            new Test(i); // Test(int i): 1, 3, 5, 7, 91 C3 |4 E0 ?6 M& e* p7 r
        
( r; `2 u1 K0 S  ]& S    if( i < 4 )# i6 y& q0 c3 F2 n8 f7 x
        new Test(*a1);; {' ~# }0 E1 d# m
    else
5 h2 @; `0 Z$ J, G" Y: M: B        new Test(100); // Test(int i): 100
# K: C5 \, t, G& @        * K  \* D# i: a0 W# M8 Q
    return 0;
  r: E* P8 i% z) l}
. v% I' ^" |# K. K
5 g, e8 z- ]# `6 m  G* d" a* }
输出结果:
Test(int i): 0
* ^  U% Z5 u7 i" ~+ e& pTest(int i): 1
" c( I/ E# c6 k3 m+ J& xTest(int i): 3
5 P! R5 I# S2 Y6 H3 u0 @Test(int i): 51 J* ]8 l9 x7 p
Test(int i): 70 I4 v9 p2 j; r( d
Test(int i): 9
7 n3 r6 ]( w* hTest(int i): 100
$ C+ }: K! z. N

' F  h5 r8 q  K& D& h+ }
3、对于全局对象:
  • 对象的构造顺序是不确定的
  • 不同的编译器使用不同的规则来确定构造顺序。
    1 J7 f9 I. w1 L5 q* w
同样还是来看代码示例,这里我创建了几个文件:tes1.cpp   test2.cpp   test3.cpp   test4.cpp    test.h;他们的内容如下:
test1.cpp:
#include "test.h"
; {) c- m9 ~) z
) i  s4 k5 U6 [0 _# o  T/ aTest t4("t4");
3 G2 w7 {3 H: }: A1 y
/ [* x; t# u: W4 ]2 e) U- fint main()
9 p" M  d6 J. f- c# Q! K9 e{
. ?% L1 }4 N; K1 k5 M2 M1 A& D    Test t5("t5");% U/ `1 F. m5 ?/ `
}
& Y/ |1 O+ p1 }" B7 r! ^
test2.cpp:
#include "test.h"
! q! G. k8 V4 z3 O7 X3 n  c
3 @" j! z9 I. ^* {" d* }Test t1("t1");
# [3 x( C5 T( y, ]0 F0 u0 m

  {" _2 J1 a# F8 L
test3.cpp:
#include "test.h"/ y& z& n! L) A  k

( u" w- q2 Q1 q8 ]! V: P6 zTest t2("t2");8 B+ Z1 S) R6 i  g( ]
. a+ e; n# M6 l; L" r! o  Q
test4.cpp:
#include "test.h"
7 X4 B! x' }- X0 W) Q: _3 ]2 t0 \  m+ L5 J- `: U) T$ h1 ^* D
Test t3("t3");) a2 ~9 I& i$ |0 k- C3 B; k
, G0 U) W/ I) ]2 ~4 [: q
test.h:
#ifndef _TEST_H_
: B& \1 K8 C  t8 O/ R* ~' |+ N#define _TEST_H_
4 Q/ f0 `. H% m, m( t- {5 \
, S+ u8 v% y9 T! b+ s#include <stdio.h>  a) [) M, l- X* M
4 w7 J4 S$ k/ Q  a
class Test
9 _, U4 R5 e# d) ?{1 ]* }0 @* u# B/ v/ [& l5 [
public:
& Q1 i/ ^" Y0 u# j% m0 A    Test(const char* s)
' E. h$ Z  H3 {! |    {& B2 ?. Y  l* P2 @& b8 q
        printf("%s\n", s);
6 Q& _; ]; x. r# O0 u" d0 S; s# w    }
9 d8 u# O! N3 ]% V2 g};, e. B4 q" J3 \) e6 W; ]3 N+ S
# ?  g; U& F% Z( j; W& }. E- z
#endif
" i" `: E' w5 ^9 J
$ m$ r6 O! l) P
最后输出结果:
root@txp-virtual-machine:/home/txp# g++ test1.cpp test2.cpp test3.cpp test4.cpp -o put3 q# N% W9 Z, X/ H- [
root@txp-virtual-machine:/home/txp# ./put$ q9 y% B# _" @1 t: j. c. \: M% r
t4
5 T5 J/ j/ |3 I6 Tt1
; M) U6 F- T! c$ Xt2  W2 B# x* T& J( g
t3
( h0 `$ U$ {# v& u4 ]8 I, Ot5
7 H0 O$ ~- K7 ~+ l
; J! u  D0 y- Z! o% Z3 _' @- A
4、小结:
  • 局部对象的构造顺序依赖程序的执行流
  • 堆对象的构造顺序依赖于new的使用顺序
  • 全局对象的构造顺序是不确定的

    4 v8 K+ Y6 z$ _2 s3 G) {# Y
二、析构函数:
1、c++的类中可以定义一个特殊的清理函数,叫做析构函数,这个函数的功能与构造函数相反,顾名思义就是销毁的意思了。
2、定义:~ClassName()
  • 析构函数没有参数也没有返回值类型声明
  • 析构函数在对象销毁时自动被调用

    9 G7 [; g& u0 s; ]/ X/ k' y
代码示例:
#include <stdio.h>4 c) p; K. D; v  U! F# q+ c
; w. r0 }. x6 a
class Test
9 f6 A- E: ?; x1 H. s{
: }9 b7 y$ G+ U( s: Q    int mi;
( }, L; z: a) D) J1 Fpublic:
- @! T1 N: k- B! r4 b# P" U0 L    Test(int i)
$ x  M! b0 K+ F5 p& }9 i( U6 o* \    {
  T) ?5 s# t/ N        mi = i;
# m1 b8 e/ u& p+ M( Y# X! A( y. c% |        printf("Test(): %d\n", mi);& Y/ z/ x7 o; H2 I" s2 d6 t
    }( O% {8 X0 M1 j, _' g1 ?
    ~Test()
: U- ]- i2 ?# U+ c    {" z6 ~# X( y; \  q  V( w
        printf("~Test(): %d\n", mi);
2 D& m+ \5 p1 O9 D    }
+ ?, _; t1 f9 \! y( W" |};& {4 N, k7 \5 [5 d9 q
- I2 Y9 {% Z. i/ s, c
int main()" P; V3 }4 Z+ s. h5 ^) h& y
{* G, r0 Z9 c0 n, Q/ Q/ S) J# A
    Test t(1);# x' q" d- F: p
   
. ~% D- s6 Z; v) M/ `4 c    Test* pt = new Test(2);+ m: Y4 V5 r& B5 q
    " J% L: a9 r' b, M, p3 p5 Y8 m
    delete pt;+ D1 b) ^5 r& p/ W. ?* b! U
    & r6 F, w) K9 A. ^6 v; }# A2 ]1 X
    return 0;" X" G0 q& V+ n, d8 F/ O- w8 F
}5 I) q, G' E2 F, J- a  M

5 r% H1 N; C, ]
输出结果:
Test(): 1
+ p: h  m$ ~% Q  D4 T1 X9 f/ B! {Test(): 2
* R6 C! K5 }: I~Test(): 22 q7 e% R8 ~, R
~Test(): 1
: t8 p5 g  k& b( t
) [$ {9 P+ T: d4 l7 Q1 h$ D
3、析构函数的定义准则:
当类中自定义了构造函数,并且析构函数中使用了系统资源(比如说,内存的申请,文件打开),那么就需要自定义析构函数了。
4、小结:
  • 析构函数是对象销毁时进行处理的特殊函数
  • 析构函数在对象销毁时自动被调用
  • 析构函数是对象释放系统资源的保障
    $ q' g$ L7 Y* G) J/ Z  q* c
赞 收藏 评论0 发布时间:2020-8-4 23:01

举报

0个回答
关于
我们是谁
投资者关系
意法半导体可持续发展举措
创新与技术
意法半导体官网
联系我们
联系ST分支机构
寻找销售人员和分销渠道
社区
媒体中心
活动与培训
隐私策略
隐私策略
Cookies管理
行使您的权利
官方最新发布
人形机器人运动控制、感知与智能配电
半导体创新技术与应用方向
EE架构与软件定义汽车
12V/48V 汽车智能配电(SPD)
区域控制单元(ZCU)与分区架构
关注我们
st-img 微信公众号
st-img 手机版