& B% Q& x9 i% }8 [继承和派生的概念
' v) v4 _( C1 {6 Z7 f" Y$ {) ]
0 i, c$ b7 c6 S# q2 @# f  E01派生
+ i' d) i* d3 Z% R$ h

1 N0 p. c% u9 F+ ]+ J

通过特殊化已有的类来建立新类的过程，叫做“类的派生”， 原有的类叫做”基类”，新建立的类叫做“派生类”。

02继承
, v5 z# n7 v; z% [' K3 P

- S! \* h+ o: `& f7 U

类的继承是指派生类继承基类的数据成员和成员函数。继承用来表示类属关系，不能将继承理解为构成关系。

! ?/ Q! E- l8 k2 d03继承派生的作用

• 增加新的成员（数据成员和成员函数）
  
  

• 重新定义已有的成员函数
  
  4 l5 r: U* u0 r  U3 F6 y9 G

• 改变基类成员的访问权限
  
  

单一继承

01一般形式
% z/ _5 {) H/ U# v3 H

   代码格式：

1. 
   : i# y4 k7 K1 T8 `) ]. [) s3 v6 c. X
2. class 派生类名: 访问控制 基类名 {
   ( M1 a  L. J6 `' C
3.         private: 成员声明列表
   ( n/ X9 B, t. X  c. s8 E
4.         protected: 成员声明列表
   ( E2 X4 d# X9 d/ l( H2 O2 W
5.         public: 成员声明列表
   
6. }

复制代码

: {: K, u, Y! V& _% r9 |. D4 U/ E

“冒号”表示新类是哪个基类的派生类；“访问控制”指继承方式。

三个方式：public、protected、private

- |7 P4 v5 I% W' i# ^) a9 e; Q02派生类的构造函数和析构函数

1. 
   
2. // 基类
   ! x$ A/ F$ p4 h
3. class Point {
   
4.     int x;
   6 Y0 w6 p: r4 s: W2 ?- b
5.     int y;
   
6.    
   
7.     public:
   ) v9 H+ c  r! ?& g2 R
8.     Point(int a, int b) {
   
9.         x = a;
   ) i; L, N) `" z
10.         y = b;
    
11.         cout << "init Point" << endl;
    
12.     }
    % b) j1 w% X+ |% V5 u
13.     void showPoint() {
    : `/ N& }/ w6 p8 z1 I2 ?0 y
14.         cout << "x = " << x << ", y = " << y << endl;
    4 U$ b( x9 y) E2 U3 ^; L, }9 M
15.     }
    
16.     ~Point() {
    
17.         cout << "delete Point" << endl;
    6 X8 K& V' b* e5 R" a. a6 W
18.     }
    
19. };
    
20. 
    4 V% s# q( s7 _
21. // 派生类
    
22. class Rect: public Point {
      D1 f) Z# r+ f5 d/ r, X+ j
23.     int w;
    5 f; E2 P; `3 n; V. {! C6 E
24.     int h;
    ; c4 z2 b+ z- }% Q# n3 y
25.    
    
26.     public:
    $ \+ ^6 @4 Z* Z+ Q5 s3 f+ z
27.     // 调用基类的构造函数对基类成员进行初始化
    
28.     Rect(int a, int b, int c, int d):Point(a, b) {
    
29.         w = c;
    . [' ?) Z; t% t& [8 b
30.         h = d;
    , w# R, M9 B9 @& k5 L8 i( E* P+ x+ x
31.         cout << "init Rect" << endl;
    . x/ [3 m5 W) y4 ^$ h, n; C
32.     }
    8 {' H( G9 X* W" ?
33.     void showRect() {
    ) E* \& s5 v3 r3 k( x8 H' K3 z
34.         cout << "w = " << w << ", h = " << h << endl;
    7 w% e- w. r4 W( i3 n, ]2 h" |
35.     }
    : b4 x' v. U* \& v" |
36.     ~Rect() {
    # F4 Z9 z& s' C
37.         cout << "delete Rect" << endl;
    
38.     }
    
39. };
    & w' y2 I) o, |8 R2 p5 t5 k+ x
40. 
      g# z9 D) G! I
41. int main() {
    ! U3 E6 u. o, x
42.     Rect r(3, 4, 5, 6);
    5 H7 ~+ O* W" S9 ^! T
43.     r.showPoint();
    ; Y' W4 R/ G1 n
44.     r.showRect();
    ! }5 _* _$ ?1 J4 A' k! V: U9 i8 ~
45.    
    3 Q0 H- N6 H& c3 D/ f! t. J' n
46.     /** 输出结果
    - f% }& U5 I8 y4 ~6 g
47.      init Point // 当定义一个派生类的对象时, 首先调用基类的构造函数, 完成对基类成员的初始化
    
48.      init Rect // 然后执行派生类的构造函数, 完成对派生类成员的初始化
    6 M) o/ R; y1 Y" Y
49.      x = 3, y = 4 // 调用基类成员函数showPoint();
    / s7 Q. M6 c) i9 B
50.      w = 5, h = 6 // 调用派生类成员函数showRect();
    ( i# q: K' I- A; T0 U8 e- [# @( G9 N
51.      delete Rect // 构造函数的执行顺序和构造函数的执行顺序相反, 首先调用派生类的析构函数
    : t  U% }  J% e- n( s2 h9 Q
52.      delete Point // 其次调用基类的析构函数
    4 e9 }3 Z6 p' y1 @9 N
53.      */
    & ]) d* P: B5 L- k; \8 R, l* G; e9 S
54. }

复制代码

  c+ d. e: V! I2 \+ R) B4 _03类的保护成员

" w9 ~5 |# u! v2 A' `6 s! P

如果希望Rect中的showRect()函数可以一次显示x、y、w、h。我们直接修改showRect()函数是不行的。

1. 
   
2. void showRect() {
   
3.   cout << "x = " << x << ", y = " << y << ", w = " << w << ", h = " << h << endl;
   2 a  |, G+ {- s& h0 o! ~: y3 ]
4. }

复制代码

报错 error: 'x' is a private member of‘Point' 'y' is a private member of‘Point'  

5 F& d/ t8 |* M+ I0 T

x, y为Point类的私有成员，公有派生时，在Rect类中是不可访问的。

$ P0 o" _6 b/ n; `" x0 k

我们还需要将基类Point中的两个成员声明为protected的属性。

7 x6 V" f! o, K

像这样：

1. 
   
2. // 基类
   
3. class Point {
   . d4 \  F, X/ _$ l4 f2 _
4.     // 公有数据成员
   
5.     protected:
   
6.     int x;
   6 A, J1 z. Y% a
7.     int y;
   
8.    
   3 |( j; l5 c- ^! \3 u
9.     public:
   + h* C: M# m7 d( [2 M. s
10.     Point(int a, int b) {
    ! n$ I# S, ^) E+ F- g1 f. ?9 N; \: s
11.         x = a;
    5 _0 z) r; B0 v7 v  X+ x
12.         y = b;
    
13.         cout << "init Point" << endl;
    - d0 M4 A5 [7 k5 P. s. B$ H
14.     }
    
15.     void showPoint() {
    - o! W" h7 b% x
16.         cout << "x = " << x << ", y = " << y << endl;
    , N9 X" M7 X/ [4 B
17.     }
    
18. };
    ( M! s# u% j+ [. q8 ^# q
19. 
    ! Z" @, y& ]# M: Y
20. // 派生类
    
21. class Rect: public Point {
    5 j; \# T1 N; c: Q4 w
22.     int w;
    
23.     int h;
    
24.    
    ' A+ ]: p4 t- P- \+ l
25.     public:
    $ p& K7 C& p3 h9 w7 _# I; V! i0 s- Q
26.     // 调用基类的构造函数对基类成员进行初始化
    
27.     Rect(int a, int b, int c, int d):Point(a, b) {
    
28.         w = c;
    
29.         h = d;
    
30.         cout << "init Rect" << endl;
    
31.     }
    8 `) G) Q6 k! R8 c: M  N
32.    
    
33.     /** 公有派生, Point类中的受保护数据成员, 在Rect类中也是受保护的, 所以可以访问  // 而通过公有继承的基类私有的成员, 在派生类中是不可被访问的    void showRect() {
    7 q0 Q/ Q' v' Z# I, O
34.         cout << "x = " << x << ", y = " << y << ", w = " << w << ", h = " << h << endl;
    + e* }1 O( ^, P  S: S" J6 v
35.     }*/
    
36. };
    
37. 
    
38. int main() {
    6 x: _9 N  g6 k+ G! Z2 Q
39.     Rect r(3, 4, 5, 6);
    ! Y3 v" C* I2 t3 w* B
40.     r.showPoint();
    $ I( s  Q  J3 M5 Y6 Q. Q
41.     r.showRect();
    
42. }

复制代码

3 J2 d8 @$ H* I$ b& |04访问权限和赋值兼容规则

$ t) O! |# ?9 l& C/ Y7 m

在根类中，对于成员的访问级别有三种：public、protected、private

在派生类中，对于成员的访问级别有四种：public(公有)、protected(受保护)、private(私有)、inaccessible(不可访问)

, F% Q& F6 W/ C% B/ }; v

（1）公有派生和赋值兼容规则

公有派生：

基类成员的访问权限在派生类中基本保持不变。

2 K7 l0 g! I  z

• 基类的公有成员在派生类中仍然是公有的
  
  

• 基类的保护成员在派生类中仍然是受保护的
  
  ! u& j9 O# a+ J# \7 p! ^, k  j1 N5 P* Q

• 基类的不可访问的成员在派生类中仍然是不可访问的
  
  

• 基类的私有成员在派生类中变成了不可访问的
  
  5 H  w% b3 C& D3 F( C9 P6 W

# }- P% y" f' k$ y0 e9 Z0 {

总结：在公有派生的情况下，通过派生类自己的成员函数可以访问继承过来的公有和保护成员, 但是不能访问继承来的私有成员， 因为继承过程的私有成员，变成了第四个级别，不可访问的。

赋值兼容规则：

在公有派生的情况下， 一个派生类的对象可以作为基类的对象来使用的情况。

像这样：

1. 
   
2. // 基类
   
3. class Point {
   ( F) ]( [+ y; J6 ^6 S2 p+ v
4.     // 这里声明成员属性为受保护的
   & W+ u3 `  Y. ^& w/ J
5.     protected:
   
6.     int x;
   
7.     int y;
   
8.    
   & ^2 g; e6 f' q( E8 D
9.     public:
   ; Q  O. i1 r) L% d
10.     Point(int a, int b) {
    
11.         x = a;
    * `4 Y/ O1 p" [# f  q
12.         y = b;
    
13.     }
    
14.    
    4 w) X, N+ @9 |) V4 w5 F2 ^
15.     void show() {
    2 D4 g2 ?1 p3 [8 d8 v; F
16.         cout << "x = " << x << ", y = " << y << endl;
    
17.     }
    & `" p0 p$ @6 _2 ^0 V3 T' s+ b, W) n8 I. @) j
18. };
    
19. 
    2 l6 Z1 j% Y& s! n% o# x3 r% L
20. // 派生类
    : ]* A" d3 \5 }# R
21. class Rect: public Point {
    
22.     int w;
    ; Y& N9 y. j/ H1 a
23.     int h;
    
24.    
    
25.     public:
    
26.     // 调用基类的构造函数对基类成员进行初始化
    ' M% R4 }! m: E  A- U. Y& e
27.     Rect(int a, int b, int c, int d):Point(a, b) {
    
28.         w = c;
    . K: ]3 i' L+ E) O. z7 M, X2 o
29.         h = d;
    + T  K9 n! [" a/ R* Y9 o! L
30.     }
    $ y) t% j% D# N9 S  z
31.    
    # t$ n# B; ^' c& R, D
32.     void show() {
    
33.         cout << "x = " << x << ", y = " << y << ", w = " << w << ", h = " << h << endl;
    
34.     }
    % |0 F& D  R! S; f9 |: H9 k3 v
35. };
    
36. 
    3 u4 D: h( z; @2 E
37. int main() {
    6 I. ?6 j% F/ Q
38.     Point a(1, 2);
    
39.     Rect b(3, 4, 5, 6);
    
40.     a.show();
    
41.     b.show();
    9 C" A" ~0 z0 B
42.    
    
43.     Point & pa = b; // 派生类对象初始化基类的引用
    0 N, m4 i8 n0 X2 f8 d" j1 c- d, o
44.     pa.show(); // 实际调用基类的show()函数
    
45.    
    % S1 x; t" h0 _2 |
46.     Point * p = &b; // 派生类对象的地址赋值给指向基类的指针
    % ~/ x3 }' [- X
47.     p -> show(); // 实际也是调用基类的show()函数
    
48.    
    
49.     Rect * pb = &b; // 派生类指针
    
50.     pb -> show(); // 调用派生类的show()函数
    / ]) n! r5 V6 Z0 C: `
51.    
    & ?+ X9 W$ q$ K+ P: x, w1 d5 r
52.     a = b; // 派生类对象的属性值, 更新基类对象的属性值
    
53.     a.show(); // 调用基类的show()函数
    
54.     /**
    ) X$ W; V6 V, i( \0 W  O3 q+ r
55.      x = 1, y = 2
    
56.      x = 3, y = 4, w = 5, h = 6
    4 p0 v; K- X9 D2 b
57.      x = 3, y = 4
    % v3 b" p' |0 i
58.      x = 3, y = 4
    4 A8 b  L$ G. Z
59.      x = 3, y = 4, w = 5, h = 6
    
60.      x = 3, y = 4
    
61.      */
    
62. }

复制代码

（2）“isa”和”has-a“的区别

继承和派生 isa

: \9 C$ p% K9 \3 R5 c0 V( q" l

比如一个Person类，派生出一个Student类，我们可以说Student就是Person，也就是 Student isa Person，而反过来则不行。

一个类用另一个类的对象作为自己的数据成员或者成员函数的参数 has-a。

像这样：

1. 
   
2. // 地址类
   
3. class Address {};
   9 ?4 D! I: Q6 U  Q3 R
4. class PhoneNumber {};
   
5. 
   / C- S* I3 |9 z5 q! {
6. // 职工类
   
7. class Worker {
   6 t# {4 P% e& ?* ^0 _
8.     String name;
   
9.     Address address;
   
10.     PhoneNumber voiceNumber;
    7 u  q, j# M; l# b6 f* T' T
11. };

复制代码

表示一个Worker对象有一个名字，一个地址，一个电话号码，has-a的关系，包含的关系。

: k: E. G! F8 k6 @

（3）私有派生

通过私有派生，基类的私有和不可访问成员在派生类中是不可访问的，而公有和保护成员这里就成了派生类的私有成员。

1. 
   $ r  Y) b: {+ ~
2. // 基类
   / V* @) g# j1 ^' A6 B  f* }/ y
3. class Point {
   
4.     int x;
   
5.     int y;
     b, W; u. }3 c: q8 |+ ]+ L
6.    
   9 e# ~3 C/ U& s4 v6 W: s2 `
7.     public:
   
8.     Point(int a, int b) {
   
9.         x = a;
   . Q" l, ^0 I5 v6 k5 W. \+ c3 X
10.         y = b;
    * d) e- C/ g* A
11.     }
    
12. 
    
13.     void show() {
    
14.         cout << "x = " << x << ", y = " << y << endl;
    
15.     }
    1 e" h( \* k' m% n
16. };
    
17. 
    3 F' Z6 `( c0 C9 ?% p* u
18. // 派生类
    ( r; S$ h4 _7 W  {6 W5 F" o1 w1 }7 M
19. class Rect: private Point {
    
20.     int w;
    4 @$ e! w& s# r5 p2 w
21.     int h;
    
22.    
    
23.     public:
    
24.     Rect(int a, int b, int c, int d):Point(a, b) {
    
25.         w = c;
      [. y# N/ l. K! T' b6 n" G
26.         h = d;
    
27.     }
    1 f% o! O* o( F1 a" T
28.    
    7 |% l- O6 R7 \2 `, X7 Z# `& l( L4 x
29.     void show() {
    8 t8 Z: R3 a! ~
30.         Point::show(); // 通过私有继承, Point类中的公有成员show(), 在Rect中为私有
      ^# M7 q- R. R% U- L3 A" _2 a
31.         cout << "w = " << w << ", h = " << h << endl;
    " S1 n* g3 }5 P1 `
32.     }
    + j& Q3 q' [1 H- V
33. };
    
34. 
    
35. class Test: public Rect {
    
36.    
    " n, i) g& D8 C2 t: u! Y
37.     public:
    
38.     Test(int a, int b, int c, int d):Rect(a, b, c, d) {
    . a; W% l' l  g6 M) V- V2 i: C
39.         
    
40.     }
    + i; P8 U$ `2 N8 G+ w
41.     void show() {
    
42.         Rect::show();
    
43.         //Point::show();
    
44.         /** error: 'Point' is a private member of ‘Point’
    
45.          标明: 不可访问基类Point中的成员
    ( R* c9 [' ~% I. h$ J6 t5 I/ C1 ^
46.          Rect类私有继承自Point类, 所以Point中的私有成员x, 私有成员y, 在Rect类中为不可访问: Point类中公有成员show(), 在Rect中变私有
    
47.          Test类公有继承自Rect类, 所以在Rect中成员x, 成员y, 仍然是不可访问, Rect::show()还是public, 但是Point::show()不可访问 */
    
48.     }
    5 G0 q  F0 @3 g" `* t& ?
49. };

复制代码

* l9 ]" m& ?) R) q" u' u  l

因为私有派生不利于进一步派生, 因而实际中私有派生用得并不多。

（4）保护派生保护派生使原来的权限都降一级使用

1 C! r) H( u) X2 G! |% a

即private变为不可访问，protected变为private，public变为protected。

" X+ Y4 y4 \+ ]. s9 T. R! g+ A' Q+ u

限制了数据成员和成员函数的访问权限，因此在实际中保护派生用得也不多。

比如：我们在上个例子中，Rect类保护派生于Point，则在Test类中Point::show()；就可以使用啦！

多重继承

! d3 ?* ?/ B& K5 |01一个类从多个基类派生
8 B- `- Y' ~8 t1 [

代码格式：

1. 
   1 X5 i! i* Q- N9 U0 L
2. class 派生类名: 访问控制 基类名1, 访问控制 基类名2, … {
   
3.     //定义派生类自己的成员
   ; d0 ?/ L- N3 ?
4. }

复制代码

) u0 L5 L2 g* d: C" |/ P

像这样：

1. 
   ) X2 O8 X4 W6 p9 N. U
2. // 基类A, 也叫根类
   
3. class A {
   
4.     int a;
   9 v' }( S! M: [, C8 t, L7 Q+ |) r. I
5.    
   % ]4 F5 Z4 b0 v& ~8 U  x
6.     public:
   6 K1 ]% j5 }! ?: v! @* C1 l- V: q6 e
7.     void setA(int x) {
   
8.         a = x;
   
9.     }
   
10.    
    ; B3 Y- n% t1 p  J" Z
11.     void showA() {
    , r' k4 U  o- S7 s$ M6 T
12.         cout << "a = " << a << endl;
    
13.     }
    & \; h8 r: F+ E+ {* i( s. h% R6 @
14. };
    
15. 
    
16. // 基类B, 也叫根类
    $ P5 i6 f: Q# F- c# p
17. class B {
    + g" O3 \1 f. K* Z$ U5 g
18.     int b;
    1 x$ _% U2 h4 C9 |; Y. s+ U+ V0 g
19.    
    $ L1 O! y3 V9 ]0 x6 R- @9 C
20.     public:
    
21.     void setB(int x) {
    
22.         b = x;
    
23.     }
    
24.    
    
25.     void showB() {
    
26.         cout << "b = " << b << endl;
    ! c+ |) i! e+ ]( a; i4 d" d
27.     }
    5 Z1 U2 l" _" v+ j
28. };
    
29. 
    ! l+ H) h3 c- n5 o' \2 t$ g
30. // 多重继承, 公有继承自类A, 私有继承自类B
    1 r! l; [1 ]+ L, H/ E- g7 [
31. class C: public A, private B {
    ) y" z  a; _  z1 K. p# F) G
32.     int c;
    " t9 l) D2 j3 \$ [
33.    
    9 |& W' a: `2 T# z
34.     public:
    $ [$ p# Z1 |* F5 @4 ~3 c/ W% W
35.     void setC(int x, int y) {
    
36.         c = x;
    3 G( }3 X* }% Q8 Q
37.         setB(y);
    
38.     }
    5 V4 `* n' C! \  q1 y
39.    
    % a% G* a: c5 Y" s6 J4 [
40.     void showC() {
      v5 p5 F  F! _. C. i! ~
41.         showB();
    
42.         cout << "c = " << c << endl;
    $ ?, w) A! W5 ~5 C4 h# f
43.     }
    : C7 z( ]5 A  f) r! q# Q6 h0 j, v
44. };
    5 \/ w2 ?3 v; B
45. 
    
46. int main() {
    
47.     C c;
    2 M! r6 J0 B! X2 F2 j5 W- T! Q
48.     c.setA(53); // 调用基类setA()函数
    
49.     c.showA(); // 调用基类showA()函数
    : G  U3 _8 n% Y4 |) E) B2 x% Z
50.    
    
51.     c.setC(55, 58); // 调用派生类C的setC()函数
    $ o4 i% h, W% J! o0 `
52.     c.showC(); // 调用派生类C的showC()函数
    
53.    
    
54.     // 派生类C私有继承自基类B, 所以基类B中私有成员b, 在派生类C中不可访问, 基类B中公有成员setB(), showB()在派生类C中变私有. 在main()函数中不可访问
    $ e* A. M5 ~, G& X
55.     // c.setB(60); // error: 'setB' is a private member of 'B'
    
56.     // c.showB(); // 'showB' is a private member of 'B'
    
57.     /**
    
58.      a = 53
      C, j0 n- a$ L- G- m3 }# s
59.      b = 58
    8 b0 ^& Y! d+ f
60.      c = 55
    
61.      */
    7 o3 ^) r5 k5 [8 C( R/ r, G
62. }

复制代码

/ _" \; Y  A, v5 b* u% B  ]3 N二义性及其支配规则
$ {' U% R( X: I9 i; i" ?1 X& G

对基类成员的访问必须是无二义性的，如果一个表达式的含义可以解释为可以访问多个基类中的成员，则这种对基类成员的访问就是不确定的，称这种访问具有二义性。

6 p2 @/ z* [0 M  L' _1 b1 ?% A01作用域分辨符和成员名限定

* ]" F% C1 Y$ V# M/ o7 d! F

代码格式：

1. 
   
2. 类名::标识符

复制代码

:: 为作用域分辨符，"类名"可以是任一基类或派生类名，“标识符”是该类中声明的任一成员名，

2 a- c$ I+ C( |, @/ @

像这样：

1. 
   
2. // 基类A, 也叫根类
   
3. class A {
   - Y7 X( S. q8 z
4.     public:
   
5.     void func() {
   
6.         cout << "A func" << endl;
   
7.     }
   
8. };
   
9. 
   
10. // 基类B, 也叫根类
    
11. class B {
    
12.     public:
    
13.     void func() {
    
14.         cout << "B func" << endl;
    
15.     }
    
16.    
    ( u  \  O+ h0 V
17.     void gunc() {
    
18.         cout << "B gunc" << endl;
    % O& J9 G5 N, r& H" c- e0 m3 h- U
19.     }
    
20. };
    
21. 
    
22. // 多重继承
    / |% y7 i' D* \1 q6 I) i. U
23. class C: public A, public B {
    % X- `; X5 g7 z- _: G" d1 b
24.     public:
    
25.     void gunc() {
    ) |# A7 f  S5 [" @+ M/ }0 c
26.         cout << "C gunc" << endl;
    + d/ ^& I8 k; V" k7 N1 v5 O& F* h) r
27.     }
    4 i+ Q# Q* I( A$ J/ I  p9 R/ k
28.    
    : ~; n( j# }; ]2 b
29.     void hunc() {
    
30.         /**
    
31.          这里就具有二义性, 它即可以访问A类中的func(), 也可以访问类B中的func()
    
32.          */
    
33.         //func(); // error: Member 'func' found in multiple base classes of different types
    
34.     }
    8 I/ t" b% q7 E4 M/ {' q
35.    
    
36.     void hunc1() {
    6 b( s( Z' ]: R# u
37.         A::func();
    : U9 a6 C$ P7 ^9 b& `  \
38.     }
    ( Q+ R' v( ]' N% M2 \
39.    
    
40.     void hunc2() {
    8 e, x7 s5 C+ n, v! g6 [* v
41.         B::func();
    ) b3 [; N: b  T' s0 o8 Q
42.     }
    - A9 o% S/ S' {& \6 w; t
43. };
    
44. 
    
45. int main() {
    % D! U' o: S7 a4 O3 H5 B: w3 g9 X
46.     C c;
    & X5 A1 Z6 E; G2 m' `& B: z& X
47.     //c.func(); //具有二义性
      ^4 f/ z* c$ {" J' a5 E
48.     c.A::func();
    
49.     c.B::func();
    3 v9 K8 G+ F0 ~$ _5 g9 [1 K, x% f$ Y
50.     c.B::gunc();
    
51.     c.C::gunc();
    
52.    
    
53.     c.gunc();
    3 s4 t( C, ]8 T* A; ?9 S* N
54.     c.hunc1();
    & G: {. `6 W, T7 g( L8 o
55.     c.hunc2();
    % g% s1 m: A/ y
56.    
    , s# y1 n! E6 N9 Y' ]- E
57.     /** 输出结果
    + `+ B' r9 f: l4 q( \
58.      A func
    
59.      B func
    ' u5 x/ U; ?8 `0 P. i4 j
60.      B gunc
    
61.      C gunc
    
62.      
    
63.      C gunc // 如果基类中的名字在派生类中再次声明, 则基类中的名字就被隐藏. 如果我们想要访问被隐藏的基类中的成员则使用作用域分辨符B::gunc();
    " a2 m; i6 D/ G& [. g/ \
64.      A func
    ' H. g+ I2 A- X+ l3 o4 Y1 m1 e2 h; i
65.      B func
    
66.      */
    & s# M: I1 g7 Y. g* W- i
67. }

复制代码

02派生类支配基类的同名函数
5 F7 ]1 V7 u8 n& u" I8 U: D

; E8 o% s& W( {: V! d

如果派生类定义了一个同基类成员函数同名的新成员函数(具有相同参数表的成员函数)，派生类的新成员函数就覆盖了基类的同名成员函数。

5 a0 a, c6 B9 L) @

在这里，直接使用成员名只能访问派生类中的成员函数，使用作用域运算符，才能访问基类的同名成员函数。

派生类中的成员函数名支配基类中的同名的成员函数名，这称为名字支配规则。

& j( S% m0 A0 ]

如果一个名字支配另一个名字，则二者之间不存在二义性，当选择该名字时，使用支配者的名字。

例如上个例子中

1. 
   
2. c.gunc() // 输出”C gunc”, 基类B中的gunc成员函数被支配了
   
3. c.B::gunc(); // 加上作用域分辨符, 来使用被支配的成员

复制代码

总结
: b5 ?9 o# `. W# B& \

C++中的多重继承可能更灵活, 并且支持三种派生方式。

我们在学习一门语言的时候, 更应该把精力放在它的特性上面, 不应该用什么语言, 都用自己所擅长语言的思考方式, 实现方式等, 要学会发挥该语言的优势所在。