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

C++——类的继承关系学习

[复制链接]
gaosmile 发布时间:2020-8-18 18:09
一、类的组合关系:
1、整体与部分的关系
组合关系,从字面上来理解的话,就是谁也离不开谁,必须相互组合在一起才行,例如我们生活当中的电脑组成:
微信图片_20200818180902.png
代码示例:
#include <iostream>2 N" c" Y! p/ l2 d
#include <string>  D$ R4 q$ K! N
- h) e* r4 d, h+ x5 n
using namespace std;6 _9 [2 R% O  V8 r" K' z& E6 s4 L

4 C- C$ v: y! ?$ d$ Vclass Memory/ l1 ]8 @5 @% ~3 W' z6 L
{
5 F1 s/ i1 S5 Apublic:; z1 a% Q, w; [2 Z3 p0 m+ T
    Memory()) F4 k$ c8 J; `( w
    {
- {5 B% |2 a! M+ l  ?6 }        cout << "Memory()" << endl;4 p% M' E& C8 p* s5 P. @8 P1 T$ o
    }, ^2 l7 F8 d. ]9 a# U
    ~Memory()
' s& `- J! p8 `' Y- i4 {    {6 T& p7 v, X5 Z% ]% F
        cout << "~Memory()" << endl;
2 J2 u9 Y- ]; j3 ?2 L! u    }7 z, B. D: \0 M
};
' y+ I7 W! _! D9 X
0 n3 H% Q1 e/ X' c  |4 {class Disk% Y; U  q: R) l$ `8 U/ `, M$ E4 g
{
* R( x' M2 |; [  b: ^public:; u" a* K" V5 D, e) w; E- x- m4 i
    Disk()
, |* I7 {2 d2 h. p    {2 s2 \2 }. ^* F# W) H
        cout << "Disk()" << endl;
) ]9 O) [( l6 t8 Z/ U0 ~6 l    }' F* a5 a# G6 w3 Q* O
    ~Disk()
4 I# m) b- |3 e$ Q! c    {
$ C9 \+ r" o+ z        cout << "~Disk()" << endl;
( H# C3 ~  a; _3 t% n  w3 W5 @+ `3 C    }   
7 S# t0 p" {! H};8 ]7 P; y6 Y5 ^+ v

. [9 Q4 X2 n* e: x& m+ Dclass CPU
7 H' E( r1 {9 X3 ?{
# Y# C: }. C. _! s/ b# Wpublic:- |# ]2 G' p! T  o1 |% i+ u; k' N
    CPU()
6 D- z# L3 m5 ^/ C% K    {
* _0 M1 m* ]. A! ^1 @7 e        cout << "CPU()" << endl;
$ t- R' _+ P& D9 D    }5 h- l2 E. }  I( N" ~- m$ F
    ~CPU()6 x+ p- ?4 p9 I
    {
6 B& t! f# B# ^' `# x        cout << "~CPU()" << endl;
8 \* x' m3 I+ b  Q    }   
6 u8 X& K( `/ @( Q};
4 v5 c( w- R+ f5 {2 ]& K6 J/ [; V
class MainBoard' `- O7 {& h* A: F4 N: r
{8 ~; v( n3 A- p
public:
) |  v# B8 U( P1 @- J    MainBoard()
( p  s1 p  Z+ W" \2 c    {
3 s9 B) }5 p# {# Q5 n1 w  d" R        cout << "MainBoard()" << endl;& S5 B" p) ^( ]$ F
    }
* |* K: v8 Z# G7 a    ~MainBoard()2 D  B: R/ x5 E; a4 I* Z+ g
    {+ N7 M9 j8 n8 u# q  C% S- W% @
        cout << "~MainBoard()" << endl;
+ g: V6 n8 i9 |" J$ R( w    }    4 r/ h) E1 r$ C  j, }/ C
};; W7 p7 J& c0 b' T$ s, }5 ?

- _4 }5 x8 K& B9 ^+ `class Computer // 这个地方不仅描述了事物,也还描述了关系,里面只要有一个类不存在,电脑这个类也就不复存在了。# Y( n! {% A4 i1 c6 O
{  R9 S: T& ~6 }8 s7 |- D; x/ V) t4 J
    Memory mMem;( t. u+ ~% X3 x7 z7 q
    Disk mDisk;
) z% H3 R* z6 s; {# x  a    CPU mCPU;  p: K3 w! z) L, |( V
    MainBoard mMainBoard;
! m! c5 R/ U2 Z2 [5 y& npublic:: {) a' n) `" v
    Computer()// 这里会先调用类成员的构造函数,之后调用电脑类的构造函数,这说明了组合关系;电脑类对象的创建,要依赖上述四个类的对象的创建。
/ ~1 t2 ?1 b4 i( s; {    {$ C. [$ b+ W# ?+ P9 Q
        cout << "Computer()" << endl;
, \- i# \$ \- Z4 t+ A9 c    }* S* G! s1 s$ W
    void power()
5 T' D6 s$ @, J, s    {# l+ j# o# a4 a
        cout << "power()" << endl;
! K7 C: I: Y! m" v7 v5 _. J& }    }$ a8 [1 ~( v  x) W* C; n( N
    void reset()
/ T1 Y- ^7 ]2 ?# w7 I8 d( i    {, ^: o( x" R/ V: ~5 S; M4 ^( N; b
        cout << "reset()" << endl;
8 S1 Y) D! F' d0 u    }
4 J1 W4 R# s0 X% o# T7 m    ~Computer()// 电脑类析构的时候,也会将对应的类成员析构,这说明同生死;说明了电脑类对象的存在完全依赖于类成员对象的存在。
+ z9 `% v7 U. b+ N0 }; n& S     {
3 z6 b. v4 b+ I7 [) O7 c* [+ V    {
5 `( E6 r$ H" l2 ?+ i0 N0 Z        cout << "~Computer()" << endl;  l% M* o2 x0 V4 ?' k3 m2 p& a% a
    }
3 `: P/ e0 p$ B! V# l};; R6 O0 z$ T5 V: G
& }- I3 Y3 S! x5 n  M, L7 ?
int main()! v; S( E, _& e  S3 @% y
{   3 n! {7 c' V/ q; F
    Computer c;  R. R, i+ L& p6 |5 b
    * F4 h9 c* E" n9 R' `
    return 0;
) l8 A& B3 k  x( V}7 `1 D9 [/ Q9 a, ?! U2 i
. ?2 c6 r+ L2 y  Q' `' l
运行结果:
root@txp-virtual-machine:/home/txp# ./a.out
$ g4 U! Z. ]8 B9 p# V' aMemory()
* e5 W) s; e, b0 M1 D& WDisk()
, n. ^/ Q3 L5 }6 e9 {8 s4 I6 ]CPU()( V' a* d: j* M3 U
MainBoard(); E/ y; {; W, G7 Q0 T& w1 T
Computer()
% O$ c7 i* @) o3 ?9 i~Computer()* G" S0 y! ~9 F5 D" ~6 F- B* Q
~MainBoard()7 t3 y, ?! M7 T/ `; i+ W* P( B
~CPU()8 O0 K% G7 f( E/ |9 R% m4 Q( M
~Disk()( b) s: m* c* G& E
~Memory()& I9 k  j; D* `& `: i, ]; q5 c. M$ q
- k. Y! u# |, {8 r# |
2、组合关系的特点:
  • 将其它类的对象作为当前类的成员使用
  • 当前类的对象与成员对象的生命周期相同
  • 成员对象在用法上与普通对象完全一致

    ' N! A4 k5 G! e, x6 Q7 R3 [
二、类的继承关系:
说到这个继承,你可以把它类比成生活当中的父亲和儿子,儿子继承的父亲的长相特征。那么在我们面向对象中继的承又是指什么呢?
1、面向对象中的继承是指类之间的父子关系
  • 子类拥有父类的所有属性和行为
  • 子类就是一种特殊的父类
  • 子类对象可以当作父类对象使用
  • 子类中可以添加父类中没有的方法和属性

    + j0 S  G( K$ D; w: f
2、继承代码描述形式:
class Parent
) l( J* Y, \" Z, i4 I{
& Z# s  `+ _. P4 _! L    int mv;& D' h. }! t6 V
  public:
* t" i, R$ Z& x9 E' @    void method()# q% B8 V$ x& z& K" @
    {
1 |; P4 @( f; m6 W    ( Y  U7 @  q. N  _- C
    }' N$ X- R- g! u+ r6 Q3 `" d
};
3 q, I, y8 }! P6 N+ z! O! iclass Child : public Parent//描述继承关系  n! ]# t$ \7 _0 `  O4 n4 o* K
{* b2 z2 s* }: f4 {$ x

' u+ n) Y3 l$ K  m4 W6 O, n};
$ C6 I. r5 G9 e
代码示例:
#include <iostream>
/ b: q4 A" A6 q, g#include <string>
, F3 A# i8 H4 x' f
7 y) r5 N8 v; k" Husing namespace std;* F' ~. j: _( B- J" f4 r
3 _+ Z& Z6 X3 g: B
class Parent" j0 v4 G& E9 M$ \, H2 N
{& W4 {/ j* N2 w8 A
    int mv;
! a1 `: I0 i( B9 d. Xpublic:' K) u1 U0 m# O0 m, t- Y- J1 u
    Parent()
! B  {/ p- w! v& C( ?    {0 ^) b+ R- F% T$ e, }. \) v' i4 d1 G
        cout << "Parent()" << endl;) P" E/ R8 J" s% \
        mv = 100;; m9 Q' x% j& Y; }$ n4 `
    }+ x. n( L6 A& \& f  |
    void method()$ C1 m9 K- O) l
    {
0 x* H2 A  E8 P! u8 b: B5 ], j) R        cout << "mv = " << mv << endl;
/ n  v- l6 P: ^! n! H( V    }
, v* n0 [/ D- Q1 ~};
: V$ `$ O& }& ~3 |8 g1 i1 M4 f2 v* i/ K! g
class Child : public Parent
: q; R2 K3 t! W6 D+ H{
; c, _" n! |" t9 {# Rpublic:
/ p% s7 Z8 O; V& w+ n9 d; H    void hello()
/ }9 {3 V# F/ H2 ~$ W& R: P/ |    {5 W3 Q/ B7 ?* D) K* o. G
        cout << "I'm Child calss!" << endl;
( C( T% t+ u9 S4 W; y* T: X    }
/ n$ G+ X% D- y$ B$ Q};
$ }! ?7 ]  |: D& a* v/ v" D# l
# g- F" ^$ U& k! u' N9 h8 `int main()0 Y" K) D+ z8 g( t" o) i/ {
{   
4 G6 F  G, T/ j    Child c;0 z4 x% v# M. B1 x
    8 o  t; U& r) h0 L
    c.hello();: y  C' r6 B, b) i/ a1 L
    c.method();
3 [2 L) b; B3 q: E/ ~   
, Z" Z$ n) {2 r    return 0;
( d& z8 s: G& }}% @, s4 P* M$ S* Y% _

) Y* V8 J+ x" m- R  N
运行结果:
root@txp-virtual-machine:/home/txp# ./a.out
" O" ?( E  Q$ p" BParent()
3 ~1 Z" R% {& v7 }" ]& n3 cI'm Child class!+ f$ k* @8 v7 o; ]
mv= 10
, C2 z/ F6 M1 u2 V% w. x* @8 G6 j4 q( F# N: Z( q
3、继承规则:
  • 子类就是一个特殊的父类
  • 子类对象可以直接初始化父类对象
  • 子类对象可以直接赋值给父类对象
    # f  m6 d) r( E! @9 A, }
说明:继承是c++中代码复用的重要手段。通过继承,可以获得父类的所有功能,并且可以在子类中重写已有的功能,或者添加新功能。
代码示例:
#include <iostream>5 G" w7 A- Z. X. L5 ~4 f  x: R
#include <string>
0 Q9 i0 @1 W( {- J- {8 Z% w* p4 E* A" G
using namespace std;0 L0 O/ W* f7 |! `, j7 b5 ^
" N' ]2 i2 e% e9 t$ U: l( C
class Memory
* @3 l7 b5 G+ j5 B{( p& B' s) D  T* k/ J* r
public:
) \9 L1 g5 X  C" i1 s+ N+ \8 g    Memory(), i. s) {+ I1 v9 x6 J9 R
    {
  q, }$ z1 `- P. K/ J6 h        cout << "Memory()" << endl;( N; Z% w9 o  T. x
    }" e8 m' b1 z3 P. o
    ~Memory()
. h- v3 y/ E( J  G: j    {- \0 E4 H( E% s. J" d: N8 ~. g9 E5 Y
        cout << "~Memory()" << endl;
' C/ F: z3 d. i  I/ _+ W+ D- y    }
# F* J* B! B" I( a; m; D6 }};7 R, m* O) {  a

! g1 R% J$ ?" ~7 z3 h& sclass Disk
7 ~4 ]+ g" e* @3 E. b0 d; Y{' h8 J- L- d" k3 _; G7 i1 ]& e" j
public:- {6 U5 x8 `) Q* \( v0 g: J
    Disk()
' `+ O4 S7 H$ U7 w" n  n1 }    {
6 {" Z) g5 S( l5 z: W7 O        cout << "Disk()" << endl;4 [: V  h4 Q/ |* ?
    }& V* s" N8 R+ O& K5 S
    ~Disk()
$ x7 x0 L( @1 E; c2 h9 u/ b/ N    {
( m, |5 G; Q8 y. j        cout << "~Disk()" << endl;
( b6 h2 e+ K. i* i    }   
' K0 w" K6 F$ L% |, P0 K};
! k% ~; J) u7 j8 o$ j+ ^$ A4 z
' l2 L/ @" X/ v' g5 I/ u- jclass CPU
& J) b5 {( e( o) ?. ?5 i{% k5 E' D( {4 k, ?1 w* C/ Y
public:2 }$ W, v9 f; f( n" R4 D% E
    CPU()% o4 j  k/ ~7 [9 a' i* j# {
    {$ H0 [' g; h4 }2 l( H
        cout << "CPU()" << endl;( k, r6 f7 a( @7 W
    }- H$ I" e3 F; s2 F% Z/ B
    ~CPU()
  U# u* I4 P8 J/ z  Q/ A    {
, y3 }4 E$ Y5 G# f* W        cout << "~CPU()" << endl;
! i0 P: x! y' \2 `' z7 P    }    , C+ v6 P. N4 z" _
};  w- ?" ^9 ^% r; N) L9 D4 A/ ^  N  R* z" L

- e& W- s6 t; M$ J* N8 Yclass MainBoard! q! `) |1 h5 S' S
{
- U* \  G8 p: v  t+ D3 a3 \public:, |6 N% `0 P6 B4 L
    MainBoard()% i( D% _# g6 R, Y
    {
1 J) |$ C, T# J  [2 k. X        cout << "MainBoard()" << endl;6 z# X2 j; v/ W. B  T7 W
    }6 y( L' H: @' a; R) b
    ~MainBoard()+ e, T* u3 a  ~
    {/ |2 S( M  G5 S8 z( Y" _0 n) {
        cout << "~MainBoard()" << endl;
+ v; J- }' Z% N# C$ A6 O    }    - ?3 g& D$ E4 T  @8 |$ B6 S" }# N
};
- s6 D1 x/ {7 g% Q7 d4 F, R, b* @* l! u
class Computer8 e8 Q+ c( e  v3 [5 v9 p
{
. t/ H! `& T/ N7 p3 N! e# |    Memory mMem;
0 ?5 Q1 ]* N7 M9 w    Disk mDisk;# l  F# W+ G! e3 W; l4 J4 z
    CPU mCPU;: O/ u* E+ E4 v1 ?1 h, M
    MainBoard mMainBoard;' E1 J' m& R0 h
public:, o( Y' R5 A2 ^+ J
    Computer()/ E0 f1 Z, a1 s# `, U, J$ D4 Q" v
    {; d0 k3 Z5 F' r: N* [% R( z1 u; ~
        cout << "Computer()" << endl;
7 ^! t& c! K, H/ N- q" P    }0 \* k6 p7 ?' [& D
    void power()5 o" W4 Z0 v; d6 u) ?
    {
7 W8 P4 R, Y8 _' ^        cout << "power()" << endl;
; a8 p1 G1 Y6 }. O) w+ K" X2 y+ c    }9 P9 H4 _3 @5 |$ \; h
    void reset()! |8 {) [5 B6 `# @
    {# q- Q9 \* v/ K# j
        cout << "reset()" << endl;
5 n5 r4 k. O5 e+ x* {+ j  ^( |/ ~    }
  s% h7 k- D6 b; \5 F4 A    ~Computer()
+ }5 \2 b# W1 B3 c6 [    {
8 V' ^3 _) {3 u( w- n% y( j/ d0 j& Z        cout << "~Computer()" << endl;5 Z" }) X' H- C# c7 D; ^
    }! H+ c6 \' j" S! Y
};
$ [; A; ~/ i* Z+ G! n& B. b" k( |& r+ B+ H8 N5 D* o
class HPBook : public Computer% v$ j$ f5 `6 I! n, e
{
. ?+ h' R/ s& v. U5 L    string mOS;
0 n% K# R9 R& H! k, b2 M' E4 rpublic:) |% l5 d4 C) c  t
    HPBook()
3 O& h' [  z8 @    {
5 R% a; s2 K; {$ X4 j7 l9 l        mOS = "Windows 8";& I  A3 `* M( A" ~& W; b2 a
    }$ C0 I9 e! M# `1 z$ D
    void install(string os)+ Q+ Y* }4 Q  }+ C% S3 M
    {
. p( Z- ~6 B. b, U' Y( G        mOS = os;* I. L$ z) m; X9 d5 h
    }
2 V& I( n, `9 g0 e) J4 u    void OS()( z4 w- b* _. f
    {
* a4 B$ q3 F4 g8 }        cout << mOS << endl;
4 y/ a* F' B: P" G    }& X3 c5 Q; c& R% z: [1 u
};6 A, S- H+ C! A7 F: E
9 y% c) l! A; }( \/ E: z0 x+ |
class MacBook : public Computer
; V* X- v5 ?  b1 Q* C8 _5 R) W{
0 y# x& l' [4 N! Dpublic:
" g: o1 v5 t4 J; @8 {3 c" _    void OS()
! V; p' d5 B, \1 B+ m    {
. S# e/ _$ b8 p        cout << "Mac OS" << endl;! R; z, P! T* Y
    }5 j& H7 ~/ q2 z% b, K+ }- F
};; t; `' B, Z/ K3 E0 d; x8 i0 I

& L8 |0 q4 l$ ~# j' Qint main()$ I8 b- s8 E* j0 Q
{   
& t, G$ {5 Y# S; }! ]7 |    HPBook hp;
9 \' z# n9 L" K' c( j/ R8 E    4 H) \9 d* i# Z" n; p& V7 X! i* z6 h: k& W
    hp.power();+ i( S1 p& `3 B# r9 P
    hp.install("Ubuntu 16.04 LTS");
! X, f' }6 v; U* a# q$ X5 F    hp.OS();
$ n* a/ S9 o3 \( l6 e% w   
# q7 W. U) o5 }- X2 x    cout << endl;
0 g" p8 f2 W3 b; j! Y' s   
9 D4 k' V+ `0 ]/ p    MacBook mac;  l, N: }! s9 V2 v) i, A8 |
    $ t8 w7 f1 k' X8 u
    mac.OS();
. u* O9 Q: i  p- c' F1 `* T5 Y    2 E/ u5 |. T3 w
    return 0;$ [7 r$ a/ N0 I" q
}
4 @0 I0 i, y: A5 O* \2 P# r
! o- z) p" p7 ~( n4 R
运行结果:
root@txp-virtual-machine:/home/txp# ./a.out
/ D) {& O9 u9 N/ x6 h1 iMemory()' j* U, N( {! m* i2 B3 G
Disk()6 q. R3 u' M8 M! @5 Y( u, I
CPU()
" y/ x- g3 ?  iMainBoard()
1 Y, n. s7 R& V% j% d( OComputer()
- i2 \" g: d8 U4 U) l% t: lpower()
; `7 b" i/ ]% q% T% [1 j( AUbuntu 16.04 LTS
7 J, ]6 X8 @, r+ s' f; _& t* |% ~3 o! B) n5 W' k: l: P
Memory()% M' [, s% e; B, a; P
Disk()
2 u6 K) v( k* E# ?6 b( lCPU()
# [5 \$ ]( p: l6 f! @MainBoard()
4 z; u; q' a6 x& h* D2 n5 M% xComputer()0 k, e3 V* a% Q" n$ ~: j1 s
Mac OS
6 Q" s& ?3 m  Y~Computer()8 y. [0 j7 `8 J
~MainBoard()
: M5 O7 l  A8 N; \0 L6 }' _~CPU()5 R8 L) ], x4 M: ^- G) {
~Disk()
! O9 ?: Y  P; u2 s- l/ O$ j/ {~Memory()
' [6 z: M- Y; z  J" Z. |~Computer(), x( q' K4 e2 P, D: Q% @- [+ y
~MainBoard()
& W/ M+ e$ H1 ?~CPU()
, {' e- r0 R, j* |. s7 O~Disk()
# v# Q5 }7 r$ c& B( h~Memory(), n% U: x: L/ g& i/ Q2 ?$ G! A
9 E( S3 m; h) y0 X( S
4、小结:
  • 继承是面向对象中类之间的一种关系
  • 子类拥有父类的所有属性和行为
  • 子类对象可以当作父类对象使用
  • 子类中可以添加父类没有的方法和属性
  • 继承是面向对象中代码复用的重要手段(换句话说,就是不要去写重复的代码,提高工作效率)

    - }( W. x2 U- g" R0 I$ l3 x
三、总结:
好了,今天的分享就到这里,如果文章中有错误或者不理解的地方,可以交流互动,一起进步。
8 ~/ T3 o  _% x
赞 收藏 评论0 发布时间:2020-8-18 18:09

举报

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