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

C++——继承中的构造和析构

[复制链接]
gaosmile 发布时间:2020-8-21 10:03
在我们前面学习过类中的构造函数,以及析构函数,那么自然而然,在继承关系中,必然是存在着析构和构造着。
一、子类对象的构造
1、问题的引出
如何初始化父类成员?
父类构造函数和子类构造函数有什么关系?
2、子类中的构造函数怎样初始化父类成员:
  • 子类中也是可以定义构造函数的:

    / J( n, F) }8 I: i1 b! Q
--必须对继承而来的成员进行初始化,那么怎样初始化呢?这里有两种方式:
-直接通过初始化列表或者赋值的方式进行初始化
-调用父类构造函数进行初始化
3、父类构造函数在子类中的调用方式
  • 默认调用
    , S% E. H$ R( h5 b
-适用于无参构造函数和使用默认参数的构造函数
  • 显示调用
    * q8 q3 Y* B, V) ^1 F& u$ t. [9 W
-通过初始化列表进行调用
-适用于所有父类构造函数
实践代码模板:
class Child :public Parent& W% B- F" n8 V" x$ R# M& ~
{
2 R5 V& I0 C  q8 P- d/ ^% d  public:
% ?  P& C" h, y' G0 T7 C     Child()//隐式调用
# v( l  c- f2 U! p1 n2 _. E  l     {( G5 }/ B  @2 ^% t7 M* ]
        cout<< "Child()" <<endl;
+ K* {5 ?* I9 L! ^9 B( {     }# _0 |" R( t0 Z+ d! J
     Child(string s)1 P: I4 T/ J: w
  :Parent("Parent to Parent")
" a7 z% o2 c, A! |  z" J  {6 E4 [# T; y( f9 g" W
     cout<<"Child()"<<s<<endl;# O% `7 a5 h3 X8 ~2 Y3 U- n% j
  }5 B5 B. q$ l; P0 I: I- g. O3 M; p
};
8 _: q+ d/ |* c# _" o* p
代码实践:
#include <iostream>9 k! B7 M4 }3 k& y9 K7 w
#include <string>
  T: ?/ y5 K: O& G8 L. v( z3 K( k- R: f  a6 D/ a% A
using namespace std;- m# G+ O7 g+ Q$ b0 i, t/ V. g  [

% [. e; t2 j) X- B0 A0 v& gclass Parent
+ f0 j8 L- j3 T; V{
$ |4 z$ d% Q$ z2 L! C. ^public:# c8 }; j" H! Y$ [+ b5 w- ?
    Parent()# N6 `. G3 c) T$ m, A# B9 ]( Z
    {
7 l. f' h2 s7 X        cout << "Parent()" << endl;
. i+ P  I+ Q2 e    }
! d, v9 B# c, j+ f. j5 J: v+ @    Parent(string s)" _( E9 D+ {: H- c
    {' f0 _6 P; @$ p3 p# F
        cout << "Parent(string s) : " << s << endl;
+ c& E" `1 X3 b5 {    }2 _. J% `: O4 y
};3 k. \0 g0 O9 s$ A$ n: A

+ L3 w0 r) t5 t2 Bclass Child : public Parent( }2 R" g; g4 O0 Z% N0 d9 y* }, y$ M
{( V: @2 `9 t1 k1 z5 r& ~. _5 \
public:$ @( f7 s' Z+ e, v+ A2 D6 T' V9 H: [
    Child()
+ }1 y) m6 O3 N5 Q2 p2 [    {
  q! u9 T! y' w. a2 c        cout << "Child()" << endl;
9 r1 C% r$ z! u9 A) }, ^    }. z6 w3 Y; e# I! J
    Child(string s) : Parent(s)
2 x$ y& T0 P2 i' A7 }    {. t* ^  y% K' x+ F8 ^
        cout << "Child(string s) : " << s << endl;! K: w, x  g6 t. P# w
    }
5 v/ W) D% S" V8 D% D. ?};3 O* G7 b1 ^, _1 n( Q  n
( t# ^3 Y+ ^& r* n) M
int main()1 H, B4 c# d9 r! r6 U
{      
) L, ?& e, K, ]    Child c;
. J  v! p- U: O    Child cc("cc");4 f' |# O& ]2 H4 M; O* y
   
' R- ?0 i4 i5 L: g1 ]1 N# a! \    return 0;* _! }' S8 V7 \! I5 x
}
. K" b: P2 l5 Z- F; Y% r5 p
% X4 R5 m! k; g" X' d% G
输出结果:
root@txp-virtual-machine:/home/txp# ./a.out& v+ `- C* k* h
Parent()
# r( c9 h% P* S/ f! b0 R9 dChild()" [: }  s, c$ ]: q# \0 I& T. X
Parent(string s) : cc
" N1 U# p9 W6 e% s. GChild(string s) : cc
9 R7 i* X; R4 d& v* D( T6 r8 r* h% k' ]
注解:通过上面的代码输出结果,我们可以发现,子类定义的对象如果没有没有传参,就隐式调用父类的构造函数;当然上面也使用了显示调用,通过初始列表的就可以看出。
4、构造规则
  • 子类对象在创建时会首先调用父类的构造函数
  • 先执行父类构造函数再执行子类的构造函数
  • 父类构造函数可以被隐式调用或者显示调用
    9 @2 ^8 e$ r, a3 {! J! ~
5、对象创建时构造函数的调用顺序
  • (1)调用父类的构造函数
  • (2)调用成员变量的构造函数
  • (3)调用类自身的构造函数

    $ J2 X" \0 W* K) G1 m' |
总结:先父母,后客人,再自己
代码实践:
#include <iostream>
  s4 ^$ u9 Q% g- J( p#include <string>
+ v# b* @+ e1 r* g0 D4 @: T/ Y* X' d5 ^# `) a) M
using namespace std;
0 g/ Q2 @: |0 l# L4 _3 ~2 B
6 y# h  w8 N9 vclass Object
, N5 V4 D0 j' S3 L9 m0 T{3 E1 C. V4 i) S- y9 t' F; A+ Y
public:# J$ p. a* v3 ]
    Object(string s)
/ G1 ?! k8 N: ~/ k5 X/ ?4 P& `- V    {) G& Z/ w& W" ^# X
        cout << "Object(string s) : " << s << endl;  G% w/ u" G9 ^6 t' @
    }
7 u2 M' l# I. m. ]# s};
/ b7 Q$ G' [9 g/ o5 V, Y1 x- B; z; v! }
class Parent : public Object  y2 t6 G0 d8 F$ f# ?1 h
{
- ~# J) y$ W/ b8 T+ V6 Gpublic:& r: L5 v9 V2 t$ {4 \( P1 [! m
    Parent() : Object("Default")* V- }1 P1 a( o' F& F" Z9 R
    {! K3 W: d4 G& \# [% {
        cout << "Parent()" << endl;
0 ]  Q% D2 r3 {* O    }
% I: T( l/ J. h  }) h9 I7 q/ y; C    Parent(string s) : Object(s)
) I7 y1 U3 f3 b6 T    {
, M( j- m6 l' B5 a, m* `' I$ X        cout << "Parent(string s) : " << s << endl;6 \- ^- d3 H9 S7 R. i  A
    }
0 v( I) b  b9 V9 I};
( h6 i/ z" \9 k7 v2 |4 z9 U( U5 K2 A+ ^1 f. \# P
class Child : public Parent
' n. A3 Z- a8 B  K( {& C{9 A5 R' y* t% o
    Object mO1;
! ^. F/ p6 f+ s5 v, ~" W# V! I0 f    Object mO2;6 B" y" r# t) J/ z. V" ^6 E
public:
, U" d6 S; M5 x$ h& }    Child() : mO1("Default 1"), mO2("Default 2")
+ N5 g& g; H% Y- v& X    {; r! s6 o8 f/ W  u- z. h
        cout << "Child()" << endl;, }7 k0 Q8 j/ k3 G
    }2 N" n, d: E. a2 G
    Child(string s) : Parent(s), mO1(s + " 1"), mO2(s + " 2")
4 O0 q& K5 n! C% B. W3 u8 j* w" Q    {
1 R% E) l. T; u2 O4 o- s7 p" Z        cout << "Child(string s) : " << s << endl;' d* T: j$ W9 u/ M* y& f
    }
1 l+ I9 G! H) t! U: P};: B2 T) Y: [! e0 t) Y$ E$ V7 g

' F. s& p; t9 A2 c1 f1 W1 kint main()
. r5 C: ?# ?; ]1 A{       9 e" x4 h6 \9 \" t; e% o
    Child cc("cc");
1 S9 r. j; C! ^5 @! {4 D   
, N. d( D7 n9 Q- h    return 0;/ I- a( W8 z- Z
}! p- M$ I! v6 S( S8 L0 P1 X7 r; P8 ^

. Y( M- {+ C, m  y
输出结果:
root@txp-virtual-machine:/home/txp# ./a.out) |* t0 Y; l3 g  R# d
Object(string s) : cc& V- R. {! `5 J) C+ q0 A& P; n
Parent(string s) : cc
' `4 p1 v! ^- @Object(string s) : cc 1
7 h3 F& Z4 V0 |- A! |! ?' ZObject(string s) : cc 21 V1 D: V9 Q4 m  a5 D5 H) t
Child(string s) : cc2 Q: s8 A* ~3 H; Z$ E) p6 U
1 A5 F- K$ {; `0 X( X9 H* X
注解:我们可以看到,先定义了一个Child对象,然后最先访问Object带参构造函数,然后再是Parent带参构造函数(说白了就是父类先触发),然后在子类Child中又包含了组合关系(也就是客人),然后Object类中的带参构造函数,最后再触发自身的带参构造函数。
二、子类对象的析构
1、析构函数的调用顺序与构造函数相反
  • (1)执行自身的析构函数
  • (2)执行成员变量的析构函数
  • (3)执行父类的析构函数

    1 L' Y  U6 g2 C; X8 m( _3 t7 t
代码实践:
#include <iostream>, }" }1 J) V9 w4 j" s  A8 C, R
#include <string>
* [" Q# K* ?, \0 |* d! y3 Z% T# S& {; a4 p  f  d3 I
using namespace std;
- S3 d4 Z, q' d  M# P- @9 a3 N7 o6 S: F/ S! a6 Z' x( Q
class Object
0 @* m! H0 {  h6 |& J  V  M' L9 A{, E, T) f6 P& s8 e
    string ms;1 |6 H. P& }% M! p. s/ _
public:6 Z* y# Y* n3 W8 D4 M8 @& a
    Object(string s)0 F" h% T! t3 V
    {: a+ X! ^  s) E* T
        cout << "Object(string s) : " << s << endl;
& T! J3 Q3 b4 ^0 ?: r* x0 m        ms = s;0 l0 {0 ?" |6 Y" B2 }9 z+ x# Z
    }! q1 i# F& S: z
    ~Object()0 X& g3 c; B7 j  v5 ]4 ?% q
    {* r- v! `5 ?. A- o0 x# h( m
        cout << "~Object() : " << ms << endl;  W+ d9 v, s4 A- }
    }
2 T, o  e, H, l: N$ r9 y' {};
- Z9 o4 H9 X2 i4 W* M* G6 X4 Q' v# A* G, T1 ^* V# ^' C. a
class Parent : public Object$ w8 n* q' |, F( c: L3 M
{
3 L) d+ a4 a" ?' ^    string ms;
" r; J: t( K) {) ~# U. ]: V7 Z3 H, spublic:
: E' \4 Z$ f. z5 M$ a" S    Parent() : Object("Default")
8 D: z( Z% a: M+ m4 e8 N    {
8 [- K; `( D. k2 d6 x4 h! ^/ u+ ]        cout << "Parent()" << endl;
* p- Z! a: F1 u6 r9 {4 _        ms = "Default";
8 t4 t& K5 g4 `    }
5 i' \% w. `1 z9 R" n    Parent(string s) : Object(s)
3 I( Q6 F  s+ g    {1 E8 l# ^( \$ D( L
        cout << "Parent(string s) : " << s << endl;
3 }  b2 t' U" ^. R+ B# r4 V' ^6 a        ms = s;
' ?& s) N0 ^  y7 b7 j    }8 P$ B% y& ~; x2 z& {
    ~Parent()
5 t! p7 r& R2 B2 m    {
: T- ~  R* G2 L5 j3 c        cout << "~Parent() : " << ms << endl;" s6 r3 |( B' X8 n# J. Z
    }
9 h$ F5 j( s2 w};
5 P- C7 F6 `# x2 ~! w( ~2 S, j( ]3 p# A' P) T
class Child : public Parent
, k/ H" K# F8 d$ i6 t{
9 `  }; l3 v! p, D# |    Object mO1;5 o1 b1 H( L7 C$ m# r" T( z
    Object mO2;  _, w+ r$ l9 p
    string ms;/ B' n% w9 R9 W$ K( n  c2 s+ m
public:
9 v* N2 I* U( H3 E    Child() : mO1("Default 1"), mO2("Default 2"). r. X5 m: M9 R# A$ H6 Y5 ?: {0 I
    {
  E1 M4 d1 y( p, W& d        cout << "Child()" << endl;
; y* t% j0 s: A4 [% K: m        ms = "Default";% K* S6 V+ u" H8 v( v, R
    }# q* |0 @) d( A/ a8 p- G. V' L" e
    Child(string s) : Parent(s), mO1(s + " 1"), mO2(s + " 2")
* i5 d6 a: B7 Q0 K    {
8 g) I5 Z; R" R1 Z# S+ c        cout << "Child(string s) : " << s << endl;% N' T- P3 r5 m0 g4 I; E& I6 B
        ms = s;. @1 I' I/ f+ s+ c7 D( F2 O( D! D: a
    }. e$ ~, ~9 V+ p/ W0 F
    ~Child()
" S3 ^7 c- l( X. f5 Z    {$ X6 Q: v+ a/ x) j" g' c5 c
        cout << "~Child() " << ms << endl;6 I# p$ S, y% z. e* M2 q" Z" ^* x. w
    }
) e5 j* m& ~5 }& B$ F, ~};' D; ~$ i) k* s3 Y2 U- t
5 O' ]& J* U) {$ i
int main()
! W' a, U( C6 C  x+ p{       9 w+ T5 [. v* w6 [/ t( C, f3 X
    Child cc("cc");- k- n( \! q: F; @; t  c0 x- r
   
3 U, S) ^! `' v& D5 V/ b    cout << endl;
5 }) Q, \. D/ w& k; r  i$ H' g" ?   
/ y' {) b: z" M# \6 N8 Z    return 0;1 h4 |( W' B. E& a9 f
}
5 }. e1 o) j' {+ }8 l
* i+ i9 D4 S6 J
输出结果:
root@txp-virtual-machine:/home/txp# ./a.out3 x1 K3 r2 S% D" @7 n
Object(string s) : cc
- `+ O8 p8 c5 w8 d6 QParent(string s) : cc) ?3 o' A3 d4 F/ J1 I5 P
Object(string s) : cc 1
3 w5 }0 w( e6 {Object(string s) : cc 2
$ q3 {3 g4 C+ KChild(string s) : cc; [1 y2 A/ `" ^( Y
0 Z( v# D) `1 B% g* `' y
~Child() cc
6 I3 t* H8 r: B( W~Object() : cc 2
4 M5 r# Q; r- I* N: y~Object() : cc 13 n5 r8 n# A) |. I4 j1 n
~Parent() : cc
7 ~# Q: o: L) O2 N~Object() : cc
) G* V7 n9 J+ S0 X3 u
3 P8 g3 P2 J: D; \0 |  O
三、总结:
  • 子类对象在创建时需要调用父类构造函数进行初始化
  • 先执行父类构造函数然后执行成员的构造函数
  • 父类构造函数显示调用需要在初始化列表中进行
  • 子类对象在销毁时需要调用父类析构函数进行清理
  • 析构顺序与构造顺序对称相反
    2 ~3 M: c" y: Z" M7 h  S
好了,今天的分享就到这里,如果文章中有错误或者不理解的地方,可以交流互动,一起进步。
: t5 t& ]0 l, S% h9 @
赞 收藏 评论0 发布时间:2020-8-21 10:03

举报

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