继承是C++语言的一种重要机制，该机制自动地为一个类提供来自另一个类的操作和数据结构，这使得程序员只需在新类中定义已有类中没有的成分来建立新类。理解继承是理解面向对象程序设计的所有方面的关键，所以本章是很重要的。
1、继承的概念：
鸭子是鸟类的派生，鸭子是鸟类的一种，鸭子又拥有自己的特征，就是会嘎嘎叫。嘎嘎叫是区别于其他鸟类的属性。
面向对象程序设计可以让你声明一个新类作为另一个类的派生。派生类（也称为子类继承他父类的属性和操作子类也声明了新的属性和操作，剔除了那些不适合与其用途的继承下来的操作。这样继承可让你重用父类的代码，专注于为子类写新代码。）这样使我们重新使用父类代码成为可能。
继承可以使已存在的类不需修改地适应新应用，理解继承是理解面向对象程序设计所有方面的关键。
2、继承的工作方式。
|
1
2
3
4
5
6
|
class student{}class gradutestudent:public student{} |
gruduatestudent类继承了student的所有成员。集成的方式是在类定义中类名后跟：public student。一个研究生是一个学生。当然研究生类也有自己特有的成员。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
|
#include<iostream>#include<string>using namespace std;class Advisor//教授类{public: Advisor(); ~Advisor();private: int numofmeeting;};Advisor::Advisor(){}Advisor::~Advisor(){}class Student{public: Student(char* pname); void addcourse(int hours, float score) { average = (semesterhours + average + score);//总分 semesterhours += hours;//总修学时 average /= semesterhours;//平均分 } int gethours() { return semesterhours; } float getaverage() { return average; } void display() { cout << "name:" << name << endl; cout << "semehours:" << semesterhours << endl; cout << "averages:" << average << endl; } ~Student();private: char name[40]; int semesterhours; float average;};Student::Student(char *pname="no name"){ strncpy(name, pname, sizeof(name)); average = semesterhours = 0;}Student::~Student(){}class GraduateStudent:public Student{public: GraduateStudent(); int getqualifier() { return qualifierGrade; } ~GraduateStudent();private: Advisor advisor; int qualifierGrade;};GraduateStudent::GraduateStudent(){}GraduateStudent::~GraduateStudent(){}void main(){ Student ds("lo see undergrade"); GraduateStudent gs; ds.addcourse(3, 2.5); ds.display(); gs.addcourse(3, 3.0); gs.display(); system("pause"); return ;} |
子类的实例化对象可以做父类实例化对象能做的任何事情，拥有父类的数据成员，父类的成员函数。
3、派生类的构造：
根据类的实现机制，派生类对象创建时，将执行其默认的构造函数。该默认构造函数会首先调用基类的默认构造函数，而基类没有默认构造函数，但正好匹配默认参数的构造函数。所以在运行结果中，gs对象的name值为no name。
派生类可以直接访问基类的私有数据成员，甚至在构造时初始化他们，但是一般不这么做，而是通过基类的接口（成员函数）去访问他们，初始化也是通过基类的构造函数。
类与类之间你做你的，我做我的，以接口做沟通。即使基类与子类也不例外。这正是类能够发挥其生命力的原因所在。
在构造一个子类时，完成其基类部分的构造有积累的构造函数去做，C++类的继承机制满意的提供了这种支持。
4、继承与组合：
类以另一个类对象做数据成员，称为组合，继承与组合都发挥了重要作用，他们将以前设计好的类采用“拿来主义”，但是两者在使用上有所不同。graduatestudent是student类的一种，所以graduatestudent享有student的一切待遇。这种关系的差别，决定了操作上的差别。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
class vehicle{};class motor{};class car:public vehicle{ public: motor motor;};void vehiclefn(vehicle& v){};void motorfn(motor &m);void main(){ car c; vehiclefn(c);//ok motorfn(c);//error motorfn(c.motor);//ok} |
汽车是车辆的子类，他继承了车辆的所有特征，而汽车具有马达，如果拥有了一辆汽车，因为汽车包含有马达，所以，同时也拥有了一个马达。
5、多态性：
gaduatestudent类对象gs调用student类的成员函数display（），该函数在输出时，没办法输出graduatestudent自己的数据成员qualiciergrade。因此在使用继承时，希望重载display（）。
C++允许子类重载基类的成员函数。
6、多态的思考方式：
若是语言不支持多态，则不能被称为面向对象的语言。
7、多态性如何工作：
为了指明某个成员函数具有多态性，用关键字virtual来标志其为虚函数。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
|
#include<iostream>#include<string>using namespace std;class Base{public: Base(); virtual void fn() { cout << "in base class" << endl;; } ~Base();private:};Base::Base(){}Base::~Base(){}class Subclass:public Base{public: Subclass(); virtual void fn() { cout << "in subclass " << endl;; } ~Subclass();private:};Subclass::Subclass(){}Subclass::~Subclass(){}void test(Base & b){ b.fn();}void main(){ Base bc; Subclass sc; cout << "calling test (bc):"; test(bc); cout << "calling test (sc):"; test(sc); system("pause"); return;} |
fn（）是base类的虚函数，在test（）函数中，b是基类base的传引用形参，base类对象和subclass类对象都可作为参数传递给b，所以b.fn（）的调用要等到运行时，才能确认是调用基类的fn（）还是子类的fn（）。
由于fn（）标志为虚函数，编译看见b.fn（）后，将其作为迟后联编来实现。因为多态性增加了一些数据存储和执行指令的代价，所以能不多态最好。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
|
#include<iostream>#include<string>using namespace std;class Shape{public: Shape(double x, double y) :xcoord(x), ycoord(y) { } virtual double Area() const { return 0.0; } ~Shape();private: double xcoord; double ycoord;};Shape::~Shape(){}class Circle:public Shape{public: Circle(double x, double y, double r) :Shape(x, y), radius(r) { } virtual double Area()const { return 3.14*radius*radius; } ~Circle();private: double radius;};Circle::~Circle(){}class Rectangle:public Shape{public: Rectangle(double x1, double y1, double x2, double y2) :Shape(x1, y1), x2coord(x2), y2coord(y2){} double Rectangle::Area() const { return fabs((xcoord - x2coord)*(ycoord - y2coord)); } ~Rectangle ();private: double x2coord; double y2coord;};Rectangle ::~Rectangle (){}void fun(const Shape & sp){ cout << sp.Area() << endl;}void main(){ Circle c(2, 5, 4); fun(c); Rectangle t(2, 4, 1, 2); fun(t); system("pause"); return ;} |
多肽类让类的设计者去考虑工作的细节，而且这个细节简单到在成员函数上加一个virtual关键字。多态性使用用程序代码极大的简化，它是开启继承能力的钥匙。