2.2 继承
面向对象程序设计中最重要的一个概念是继承。继承允许我们依据另一个类来定义一个类，使得创建和维护一个应用程序变得更容易。也达到了重用代码功能和提高执行效率的效果。
; ?' K( q' r/ A1 a4 C' U. X

当创建一个类时，不需要重新编写新的数据成员和成员函数，只需指定新建的类继承了一个已有的类的成员即可。这个已有的类称为基类，新建的类称为派生类。一个类可以派生自多个类，这意味着，可以从多个基类继承数据和函数。

: u; Z! I$ N0 @4 z

定义一个派生类，我们使用一个类派生列表来指定基类。类派生列表以一个或多个基类命名，形式如下：

1. class derived-class: access-specifier base-class
   . p& C" z5 j  C; l) ]6 P8 V8 n
2. //访问修饰符 access-specifier是 public/protected/private中的一个
   
3. //base-class是之前定义过的某个类的名称
   + a: J& K0 ^1 a
4. //若未使用访问修饰符access-specifier，则默认为private

复制代码

继承的方式有如下三种：

• 公有继承（public）：当一个类派生继承公有基类时，基类的公有成员也是派生类的公有成员，基类的保护成员也是派生类的保护成员，基类的私有成员不能直接被派生类访问，但是可以通过调用基类的公有和保护成员来访问
• 保护继承（protected）：当一个类派生继承保护基类时，基类的公有和保护成员将成为派生类的保护成员
• 私有继承（private）：当一个类派生继承私有基类时，基类的公有和保护成员将成为派生类的私有成员
  
  9 U+ p4 P& ]) ]3 t) r# u

1. /***** inherit_example.cpp *****/
   
2. #include <iostream>
   0 X  q9 c) Q+ y( P+ \
3. #include <string>
   
4. using namespace std;
   
5. /* 动物类，抽象出颜色和体重，这两种动物都具有的属性 */
   5 ~6 j/ p$ Q: V! Y
6. class Animal { //基类
   ) o+ g, n2 o& R- P; \; z& K
7. public:
   " ]) u6 O# b9 Y
8. string color; //颜色成员变量
   ' |4 ]# l" N. m2 w4 y, J/ |7 C
9. int weight;  //体重成员变量
   ! D' K" k  u& K- d8 B/ v
10. };
    
11. /* 狗类继承了动物基类，并在狗类里添加自己的属性 */
    2 j8 i# R/ y; }# F
12. class Dog : public Animal { //派生类，公有继承了基类
    
13. public:
    ) U! @' L, N/ u/ D- d  o
14. string name;
    3 a' t6 L, H' U+ I6 x: {
15. int age;
    2 S+ p4 g! S/ ~: s
16. void run();
    " s) b( l/ z7 d0 b+ F
17. };
    
18. 
    
19. int main() {
    2 i: a, ^: U6 w8 T
20. Dog dog;
    
21. dog.name = "旺财";
    , S, x, t8 a& x" R
22. dog.age = 2;
    
23. dog.color = "黑色";
    4 P0 D: \1 G9 ~0 r, L
24. dog.weight = 120;
    
25. cout<<"狗的名字叫： "<<dog.name<<endl;
    
26. cout<<"狗的年龄是： "<<dog.age<<endl;
    
27. cout<<"狗的毛发颜色是： "<<dog.color<<endl;
    3 I. n: s+ s/ J1 j
28. cout<<"狗的体重是： "<<dog.weight<<endl;
    ; X/ Q- L6 x5 O% r+ r2 \+ z7 D
29. return 0;
    - t: Z" s: h; V; r5 r% n
30. }

复制代码

执行下面的指令开始编译

4 T+ O# f2 A; t4 s7 c; D# w2 p

1. g++ inherit_example.cpp -o inherit_example
   2 T4 L) N# X! ^3 ^& u

复制代码

执行./inherit_example后结果如下

1. 狗的名字叫：旺财
   3 A' r1 Y& [0 |  r/ W) e6 I7 |1 m
2. 狗的年龄是：2
   
3. 狗的毛发颜色是：黑色
   
4. 狗的体重是：120

复制代码

2.3 重载
- z7 m( A, {1 c: X

C++允许在同一作用域中的某个函数和运算符指定多个定义，分别称为函数重载和运算符重载。重载声明是指一个与之前已经在该作用域内声明过的函数或方法具有相同名称的声明，但是它们的参数列表和定义（实现）不相同。

当调用一个重载函数或重载运算符时，编译器通过把您所使用的参数类型与定义中的参数类型进行比较，决定选用最合适的定义。选择最合适的重载函数或重载运算符的过程，称为重载决策

" s, `) ^1 G3 P$ N

函数重载：在同一个作用域内，可以声明几个功能类似的同名函数，但是这些同名函数的形式参数（指参数的个数、类型或者顺序）必须不同

/***** func_overloading.cpp *****/
6 y9 ?1 a" [! B$ B: r* r0 a! e#include <iostream>
#include <string>
6 f! ]+ e  w7 d- R1 Nusing namespace std;

  q' u5 _& e# C( i5 G0 iclass Dog {
public:
string name;
void getWeight(int weight) { //写了一个方法，以int类型作为参数
, V$ X3 z5 H+ W% G  }% @  S: s  cout<<name<<"的体重是： "<<weight<<"kG"<<endl;
}
' P+ E! g& A' F0 \! b2 }) k //以相同的函数名 getWeight，不同的参数类型 double weight，构成了函数重载
5 _4 E5 K2 R& W% P1 ~ void getWeight(double weight) {
+ o9 I+ X% Q* p2 Q# s& C  cout<<name<<"的体重是： "<<weight<<"kG"<<endl;
7 b) U! s& ^7 f% z1 M. g }
) M! ^6 A4 G6 G. k; ~7 q};

* E; g; f7 s4 l) v( c5 I( Zint main() {
2 n' C: F; y. c Dog dog;
* J4 }+ A$ Q/ L$ s2 s  H! S) [ dog.name = "旺财";
dog.getWeight(10); //传进不同的参数，程序会匹配不同的重载函数
dog.getWeight(10.5); //传进不同的参数，程序会匹配不同的重载函数
return 0;
- l" {6 A( G- t& u; K}

: R4 h& A- h, A+ q, G

1 e( C" x$ @+ k1 ^/ P7 m& G

执行下面的指令开始编译

1. g++ func_overloading.cpp -o func_overloading
   1 t" j: _7 q( }% x$ s# a$ h

复制代码

执行./func_overloading后结果如下

1. 旺财的体重是：10KG
   5 Q5 V9 E: K" R
2. 旺财的体重是：10.5KG

复制代码

运算符重载：实质就是函数重载或多态，目的在于让人能够用同名的函数来完成不同的基本操作。重载运算符的格式如下：

1. <返回类型说明符> operator <运算符符号>(<参数表>)
   
2. {
   & ?& K$ S' `" L, Z
3. <函数体>
   
4. }

复制代码

1. /***** operator_example.cpp *****/
   + _; W: {# K  v6 P: j
2. #include <iostream>
   
3. #include <string>
   7 [5 W" h/ n' j1 M6 ^( h/ d
4. using namespace std;
   1 c+ B2 E2 N. {
5. 
   * c: Y$ X7 r& @7 V6 A
6. class Dog {
   8 \) L/ W& H& V4 ]( T3 V
7. public:
   
8. int weight;
   
9. //重载“+”运算符，注意函数必须与类名同名，把Dog对象作为传递
   
10. //使用this运算符进行访问，然后返回一个dog对象
    
11. Dog operator+(const Dog &d) {
    8 ~; [! d, e" O- A8 R0 o3 j
12.   Dog dog;
    6 J) ]0 z/ S$ [: o" d+ c
13.   dog.weight = this->weight + d.weight;
    3 d( z6 A& Z9 D& \& v) n2 ~3 a
14.   return dog;
    & l# ]- l$ b0 R; X. ]# }# B
15. }
    ( v9 b5 H6 P0 z: e2 ^8 C% B+ k% M
16. };
    
17. 
    
18. int main() {
    
19. Dog dog1;
    1 `$ j& Y9 p) X. _. H) O
20. Dog dog2;
    
21. Dog dog3;
    
22. 
    
23. dog1.weight = 10;
    
24. dog2.weight = 20;
    % J* n" N! o5 \
25. dog3 = dog1 + dog2;
    
26. cout<<"第三只狗的体重是： "<<dog3.weight<<endl;
    1 i: Y7 R2 \3 x& h. N0 Y- y
27. return 0;
    
28. }

复制代码

执行下面的指令开始编译

' W" f# i" W2 ], {0 Z- @) l/ X, o

1. g++ operator_example.cpp -o operator_example

复制代码

执行./operator_example后结果如下

1. 第三只狗的体重是：30
   6 l: W. c, v( f9 A4 b

复制代码

2.4 多态

/ T$ _* J+ o/ x3 A

) c, z; z5 s- i2 {% Q/ j8 ~C++多态意味着调用成员函数时，会根据调用函数的对象的类型来执行不同的函数。形成多态必须具备三个条件：必须存在继承关系；继承关系必须有同名虚函数；存在基类类型的指针或者引用，通过该指针或引用调用虚函数
虚函数：是在基类中使用关键字virtual声明的函数。在派生类中重新定义基类中定义的虚函数时，会告诉编译器不要静态链接到该函数。我们想要的是在程序中任意点可以根据所调用的对象类型来选择调用的函数，这种操作被称为动态链接，或后期绑定。虚函数必须实现，如果不实现，编译器将报错虚函数声明：virtual ReturnType FunctionName(Parameter)
4 \2 X. E; Q! F4 {纯虚函数：若在基类中定义虚函数，以便在派生类中重新定义该函数更好地适用于对象，但是在基类中又不能对虚函数给出有意义的实现，这时就会用到纯虚函数。纯虚函数一定没有定义，用来规范派生类的行为，即接口。包含纯虚函数的类是抽象类，抽象类不能定义实例，但可以声明指向实现该抽象类的具体类的指针或引用
) {  X; e8 s" S0 `8 A5 H

$ `. V: E& n+ ]6 K, l

纯虚函数声明：virtual void funtion1()=0

1. /***** polymorphism_example.cpp *****/
   + i* L" N  b2 w2 \( K7 O+ e! c! n
2. #include <iostream>
   3 n6 q6 s* m/ E
3. #include <string>
   
4. using namespace std;
   & m9 F7 c: u: x$ e" }: w
5. /* 定义一个动物类 */
   . J1 |8 J: ], c: X
6. class Animal {
   
7. public:
   3 I0 \: d* c1 y' o( D
8. virtual void run() { //虚函数
   
9.   cout<<"Animal 的 run()方法"<<endl;
   
10. }
    
11. };
    
12. /* 定义一个狗类，并继承动物类 */
    
13. class Dog : public Animal {
    + J7 i% I4 h7 r% k3 T; L
14. public:
    0 i. C- G0 W% t( w
15. void run() {
    
16.   cout<<"Dog 的 run()方法"<<endl;
    
17. }
    + T6 z+ E3 `9 j" M& |8 _# Z6 n
18. };
    7 x$ n- t4 D- l0 _& u
19. /* 定义一个猫类，并继承动物类 */
    1 q" s- o; n  l0 C6 i
20. class Cat : public Animal {
    
21. public:
    / @9 u# a  }% S9 t& X* k
22. void run() {
    
23.   cout<<"Cat 的 run()方法"<<endl;
    ; W) ]! [% S6 Q3 K7 H
24. }
    
25. };
    
26. 
    
27. int main() {
    - ]( U3 L& H! P9 w
28. /* 声明一个 Animal 的指针对象，注：并没有实例化 */
    : f; r- B7 F3 V5 D; w& I
29. Animal *animal;
    " V4 ^* [! k7 K2 B6 E. ?+ `( Y; H
30. Dog dog;  /* 实例化 dog 对象 */
    7 [! U/ J6 p4 W% t5 M$ T5 b
31. Cat cat;  /* 实例化 cat 对象 */
    
32. animal = &dog; /* 存储 dog 对象的地址 */
    
33. animal->run(); /* 调用 run()方法 */
    " ^9 [: c- P/ V4 v8 ]9 x: A  E! f4 v7 H
34. animal = &cat; /* 存储 cat 对象的地址 */
    
35. animal->run(); /* 调用 run()方法 */
    * W* ^3 t; e( f# Q  I4 F
36. return 0;
    1 T/ \) Q& S: S. o# |& k, H
37. }

复制代码

执行下面的指令开始编译

1. g++ polymorphism_example.cpp -o polymorphism_example
   6 U/ x; \& i# @. @5 I4 V% t5 Z: N

复制代码

! ~' \; F0 [0 o% d) R6 @8 M执行./polymorphism_example后结果如下

1. Dog的run()方法
   
2. Cat的run()方法

复制代码

转载自嵌入式攻城狮

; r$ f, o+ w) d! Y
* }+ a, O/ \8 ]

" K7 N% p. m: W! J

2 m5 O1 I+ u" i+ E. D0 N