继承
1. 继承和派生的含义
如果要提高程序开发的效率，需要对已有的代码进行重用。在面向过程的语言中，重用的单位是函数（过程）。而在面向对象的语言中，重用的单位是类。
重用一个已有的类来创建新的类，一种方法是组合，它体现部分和整体的关系。
比如说要构造一辆汽车，汽车是一种复杂的对象，它由很多小的部分组成。
attachment:figure4.png
再举一个更具体简单的例子：构造一个平面图形系统，需要用到点、线段、圆、矩形、三角形等。在线段、圆、矩形、三角形等图形中，都需要表示点这个类型，比如线段需要有两个端点来表示，我们可以通过添加点类型的成员，把它们组合起来。
attachment:figure2.png
或者可以把它们之间的关系更明确的表示为：
attachment:figure1.png
再比如说一个学生类。
attachment:figure3.png
继承（派生）是类的重用的另一种方法，它体现类之间的is a的关系。如果A is a B，即A是某一种特殊的B，则我们说A类是从B类继承（inherit）的，或者说B派生（derive）出A。比如说交通工具：
attachment:figure5.png
如果A类从B类继承，或B派生出A，则我们称A类是B类的派生类（Derived Class），B类是A类的基类（Base Class）；或者说A类是B类的子类（Child Class），B类是A类的父类（Parent Class）。
- 逻辑上派生类和基类是一种is a的关系；
- 派生类是在基类的基础上添加新的成员进行扩充而得到，它拥有基类的所有成员（所有属性和方法）；
- 在用到基类对象的地方，可以用派生类对象来代替。
比如说，学生Student是一类学校的成员SchoolMember，老师Teacher也是一类学校的成员SchoolMember，研究生GraduateStudent是一类学生Student。
attachment:figure6.png
还有各种图形之间的关系：
attachment:figure7.png
错误继承的例子：
- Rectangle继承Point？
attachment:figure9.png
- Ellipse继承Circle还是Circle继承Ellipse？
attachment:figure10.png
2. 派生类的定义
我们用C++语言来描述学生老师之间的关系：
1 struct Date {
2 int year;
3 int month;
4 int day;
5 };
6
7 struct Course {
8 string name;
9 int credit;
10 };
11
12 class SchoolMember {
13 private:
14 string name;
15 Date birth;
16 bool gender;
17 };
18
19 //Student类继承了Person类，public指明继承方式是公有继承
20 class Student : public SchoolMember
21 {
22 private:
23 string id;
24 int department;
25 int credit;
26 Date enroll_day;
27 Date graduate_day;
28 };
29
30 class Teacher; //前置声明
31
32 //GraduateStudent类继承了Student类
33 class GraduateStudent : public Student {
34 private:
35 Teacher *tutor;
36 };
37
38 //Teacher类继承了SchoolMember类
39 class Teacher : public SchoolMember
40 {
41 private:
42 int title;
43 int salary;
44 GraduateStudent *supervise[8];
45 int num_supervise;
46 };
派生类对象的定义：
对象的内存布局：
attachment:figure8.png
加上成员函数的实现：
1 struct Date {
2 int year;
3 int month;
4 int day;
5 };
6
7 struct Course {
8 string name;
9 int credit;
10 };
11
12 class SchoolMember {
13 private:
14 string name;
15 Date birth;
16 bool gender;
17 public:
18 Date get_bith() {
19 return birth;
20 }
21 string get_name() {
22 return name;
23 }
24 bool get_gender() {
25 return gender;
26 }
27 };
28
29 //Student类继承了Person类，public指明继承方式是公有继承
30 class Student : public SchoolMember
31 {
32 private:
33 string id;
34 int department;
35 int credit;
36 Date enroll_day;
37 Date graduate_day;
38 public:
39 string get_id() {
40 return id;
41 }
42 int get_department() {
43 return department;
44 }
45 int get_credit() {
46 return credit();
47 }
48 Date get_enroll_day() {
49 return enroll_day;
50 }
51 Date get_graduate_day() {
52 return graduate_day;
53 }
54 void enroll(Date day) {
55 enroll_day = day;
56 }
57 void graduate(Date day) {
58 graduate_day = day;
59 }
60 };
61 //GraduateStudent类继承了Student类
62 class GraduateStudent : public Student {
63 private:
64 Teacher *tutor;
65 public:
66 Teacher *get_tutor() {
67 return tutor;
68 }
69 void set_tutor(Teacher *t) {
70 if(tutor == t) return;
71 tutor = t;
72 t->add_supervise(this);
73 }
74 };
75
76 //Teacher类继承了SchoolMember类
77 class Teacher : public SchoolMember
78 {
79 private:
80 int title;
81 int salary;
82 GraduateStudent *supervise[8];
83 int num_supervise;
84 public:
85 void add_supervise(GraduateStudent *g) {
86 for(int i = 0; i < num_supervise; i++)
87 if(supervise[i] == g)
88 return;
89 supervise[num_supervise++] = g;
90 g->set_tutor(this);
91 }
92 };
练习：将各种图形类用C++描述出来。
3. 派生类的构造和析构
在创建对象时，我们需要对对象进行初始化。普通类型的对象的初始化是由构造函数完成的，对于派生类对象也是相同的。
创建派生类对象时，派生类的构造函数会被自动调用。
1 struct Date {
2 int year, month, day;
3 Date(int y, int m, int d) {
4 year = y;
5 month = m;
6 day = d;
7 }
8 };
9
10 class SchoolMember {
11 private:
12 string name;
13 Date birth
14 bool gender;
15 };
16
17 class Student : public SchoolMember {
18 private:
19 string id;
20 int department;
21 int credit;
22 Date enroll_day;
23 Date graduate_day;
24 public:
25 Student(string n, Date b, bool g, string i, int d): enroll_day(0,0,0), graduate_day(0,0,0) {
26 id = i;
27 department = d;
28 credit = 0;
29 }
30 };
31 int main() {
32 Student d("Jack", Date(1985, 9, 13), true, "05011101", 11);
33 }
这个例子里面，派生类Student扩展的部分已经初始化，但是基类的部分没有初始化。要初始化继承下来的基类部分的成员，可以在基类中定义构造函数。
1 struct Date {
2 int year, month, day;
3 Date(int y, int m, int d) {
4 year = y;
5 month = m;
6 day = d;
7 }
8 };
9
10 class SchoolMember {
11 private:
12 string name;
13 Date birth
14 bool gender;
15 public:
16 SchoolMember(string n, Date b, bool g) : birth(b) {
17 name = n;
18 gender = g;
19 }
20 };
21
22 class Student : public SchoolMember {
23 private:
24 string id;
25 int department;
26 int credit;
27 Date enroll_day;
28 Date graduate_day;
29 public:
30 Student(string n, Date b, bool g, string i, int d)
31 : enroll_day(0,0,0), graduate_day(0,0,0), SchoolMember(n, b, g) {
32 id = i;
33 department = d;
34 credit = 0;
35 }
36 };
37 int main() {
38 Student d("Jack", Date(1985, 9, 13), true, "05011101" 11);
39 }
如果基类中有构造函数，派生类没有定义构造函数，或者有构造函数但是没有显示调用基类构造函数，那么基类中的默认构造函数会被自动调用。
1 class Person {
2 public:
3 Person(string aname = "", bool agender = false) {
4 name = aname;
5 gender = agender;
6 cout << "Person initialized" << endl;
7 }
8 private:
9 string name;
10 bool gender;
11 };
12 class Student : public Person{
13 int department;
14 string id;
15 public:
16 Student() :department(11), id("0509342") {
17 cout << "Student initialized" << endl;
18 }
19 };
20 int main() {
21 }
如果基类的构造函数需要参数，那么需要使用初始化列表为基类构造提供参数。
1 class Person {
2 public:
3 Person(string aname, bool agender) {
4 name = aname;
5 gender = agender;
6 }
7 private:
8 string name;
9 bool gender;
10 };
11 class Student : public Person {
12 public:
13 Student(string name, bool gender, int dep)
14 : department(dep) , Person ( name, gender )
15 {
16 }
17 private:
18 int department;
19 };
在一个多层的继承结构里面，创建一个派生类对象时，所有的基类的构造函数都会被调用。
1 class Person {
2 public:
3 Person( ) { cout << "construct Person"; }
4 };
5 class Student : public Person {
6 public:
7 Student( ) { cout << "construct Student"; }
8 };
9 class GradStudent : public Student {
10 public:
11 GradStudent( ) { cout << "construct GradStudent"; }
12 };
13 int main( ) {
14 GradStudent gs;
15 }
类的完整实现实例：
1 class Person {
2 string name;
3 bool gender;
4 public:
5 Person(string n, bool g) : name(n), gender(g) {
6 }
7 };
8 class Teacher : public Person {
9 int salary;
10 int level;
11 public:
12 Teacher(string n, bool g, int s, int l) : Person(n, g), salary(s), level(l) {
13 }
14 };
15 class Student: public Person {
16 string id;
17 int department;
18 public:
19 Student(string n, bool g, string i, int d) : Person(n, g), id(i), department(d) {
20 }
21 };
22 class GradStudent: public Student {
23 Teacher *tutor;
24 public:
25 GradStudent(string n, bool g, string i, int d, Teacher *t)
26 : Student(n, g, i, d), tutor(t) {
27 }
28 };
派生类对象被销毁时，基类的析构函数会被自动调用。如果派生类和基类都有析构函数，那么他们都会被调用。
派生类构造和析构顺序
1 class Person {
2 public:
3 Person() { cout << "construct Person" << endl; }
4 ~Person() { cout << "destruct Person" << endl; }
5 };
6 class Student : public Person{
7 public:
8 Student() { cout << "construct Student" <<endl; }
9 ~Student() { cout << "destruct Student" <<endl; }
10 };
11 int main() {
12 Student s;
13 Person p;
14 }
派生类析构函数只负责派生类增加部分的分配资源的析构。
1 class Base {
2 public:
3 Base() {
4 s = new char[3];
5 }
6 ~Base() {
7 delete[ ] s;
8 }
9 private:
10 char *s;
11 };
12 class Derived : public Base {
13 public:
14 Derived() {
15 sd = new char[5];
16 }
17 ~Derived () {
18 delete[ ] sd;
19 }
20 private:
21 char *sd;
22 };
23 int main() {
24 Base b;
25 Derived d;
26 }
4. 派生类对象和对象指针的复制
有继承关系的对象复制
1 Student s("jack", Date(1980, 8, 8), true, 970101, 10);
2 Person p = s; //slice
3 Student s = p; //error
4
5 Student *pD = new Student("jack", Date(1980, 8, 8), true, 970101, 10);
6 Person *pB = pD; //correct 基类指针指向派生类对象
7 Person *pB2 = new Student("jack", Date(1980, 8, 8), true, 970101, 10);
8 pB = new Teacher; //多态性在这里体现
9 Student &rd = s;
10 Person &rp = p;
11 Student &rd2 = p; //error
12 Person &rp2 = s; // ok
13
指针类型的转换
5. 派生类的访问权限
- private成员：只在定义它的类的成员函数中可以访问，在派生类的成员函数中不可访问。基类的私有成员被派生类继承，但是不能被派生类访问
- protected成员：在本类及派生类中能访问的成员。派生类可以访问继承的保护成员，但是不能访问一个基类对象的保护成员
使用using声明改变基类成员权限
派生类的成员名字如果与基类相同，将隐藏基类成员
1 class Person {
2 public:
3 void set(string name);
4 void set(bool gender);
5 };
6 class Student : public Person{
7 public:
8 void set(int department); // hide base member functions
9 };
10 void f(Student &s) {
11 s.set("12345");
12 s.set( true );
13 s.Person::set("12345"); //ok
14 s.Person::set(true); //ok
15 }
6. 多继承
在C++中允许一个派生类有多个基类，这种继承叫做多继承。相对的只有一个基类的继承被称为单继承。多继承表达的是“派生类既是一种基类A，又是一种基类B”的逻辑关系。
比如Assistent类继承了Student和Teacher两个类：
注意：不同基类中的同名的成员会在派生类中同时存在。比如这里的name,id,level等。
多继承时对象的复制：派生类对象的指针可以赋给任何一个基类类型的指针
1 Assistant assist("jack", "12456", "assistant");
2 Student s = assist; //OK, slice
3 Teacher t = assist; //OK, slice
4 Student *ps = &assist; //OK
5 Teacher *pt= &assist; //OK
6 ps->print();
7 pt->print();
8 Person *p = &assist; //ambigius
9 Person *p = (Student *)&assist;
10 Person *p = (Teacher *)&assist;
11 p->print();
7. 虚基类
虚基类Person在派生类Assistant的对象中只有一份
1 class Person {
2 string name;
3 public:
4 Person(string n):name(n){ cout << "P"; }
5 };
6 class Student : virtual public Person {
7 string id;
8 public:
9 Student(string n, string i):id(i), Person(n){ cout<<"S";}
10 };
11 class Teacher : virtual public Person {
12 string level;
13 public:
14 Teacher(string n, string l):level(l), Person(n){cout<<"T";}
15 };
16 class Assistant : public Student, public Teacher {
17 public:
18 Assistant(string n, string i, string l)
19 : Student(n, i), Teacher(n, l), Person(n) {cout<<"A";}
20 };
8. 保护继承和私有继承
9. 多态与虚函数
相同的指令，作用在不同类型的对象上，产生不同动作。 比如：很多动物，有猫、狗、老虎等等。现在让所有的动物做一个“叫”的动作，结果…… 比如：有很多图形，有直线、方形、圆形、椭圆等等。现在让所有的图形把自己画在屏幕上，结果……
现在要求写一个函数printall显示所有人的详细信息，应该怎么做？
1 class Person {
2 enum PersonType{ P, S,T, G } type; //用来区分学生还是教师
3 };
4 void printall( Person *p[100] ) {
5 for( int i = 0; i < 100; i++) {
6 cout << p[i]->name << p[i]->birth << p[i]->gender;
7 switch(p[i]->type) {
8 case S: {
9 Student *s = (Student*)(p[i]);
10 cout << s->id << s->department;
11 } break;
12 case T: {
13 Teacher *t = (Teacher*)(p[i]);
14 cout << t->level << t->salary;
15 } break;
16 }
17 }
18 }
在每个类上增加一个print函数：
1 class Person {
2 public:
3 void print(){ cout << name << birth <<gender; }
4 };
5 class Student : public Person{
6 public:
7 void print() {
8 cout << name << birth << gender << ID << department;
9 }
10 };
11 class Teacher : public Person {
12 public:
13 void print() {
14 cout << name << birth << gender << level << salary;
15 }
16 };
17 void printall( Person* p[100] ) {
18 for(int i = 0; i < 100; i++)
19 switch (p[i]->type) {
20 case S:
21 {
22 Student *s = (Student*)(p[i]);
23 s->print();
24 } break;
25 case T:
26 {
27 Teacher *t = (Teacher*)(p[i]);
28 t->print();
29 } break;
30 }
31 }
不够简洁，理想的做法是：
但是，这时输出是
Jack 1984-1-1 false Marry 1969-5-5 true David 1983-3-3 false ……
虚函数
override虚函数
1 class Student : public Person {
2 protected:
3 string ID;
4 int department;
5 public:
6 virtual void print( ) { // override Base::print
7 cout << name << birth <<gender;
8 cout << ID << department;
9 }
10 };
11 class Teacher : public Person{
12 protected:
13 int level;
14 double salary;
15 public:
16 virtual void print() { //override Base::print
17 cout << name << birth << gender;
18 cout << level << salary;
19 }
20 };
21 void printall(Person *p[100]) {
22 for ( int i =0; i < 100; i++)
23 p[i]->print( );
24 }
这时候的结果是：
Jack 1984-1-1 false 20111374 11 Marry 1969-5-5 true lecturer 1000 David 1983-11-11 false 2012343 11 ……
调用被override的函数
多态的限制
1 int main() {
2 Person p(“Jack”, Date(1984,1,1), false);
3 p.print(); // Person::print
4 Student s(“David”, Date(1983,11,11), false, 403315,10);
5 s.print(); // Student::print
6 Person p2 = s;
7 p2.print(); // Person::print
8 Person *p3 = &s;
9 p3->print(); // Student::print 这里是多态
10 Person &p4 = s;
11 p4.print();
12 }
- 多态只能通过指针或者引用来实现。
- 非成员函数、类的构造函数、静态成员函数不能是虚函数
- virtual写在成员函数的声明中，而不是定义中
- 一般情况下，派生类要override基类的虚函数，要求函数声明形式完全一样。
例外：基类的虚函数返回基类的指针或者引用，那么派生类override它，可以返回此派生类的指针或引用
class Base { virtual Base*f(); }; class Derived:public Base { virtual Derived* f(); };- 如果派生类没有override基类的虚函数，那么派生类会继承基类的虚函数
更多例子：
问题：
1 class Shape {
2 public: virtual void draw();
3 //no virtual function in base
4 };
5 class Rectangle : public Shape{
6 public:
7 void draw();
8 };
9 class Circle :public Shape {
10 public:
11 void draw();
12 };
13 void f(Shape* s) {
14 s->draw();
15 }
16 int main() {
17 Shape *s = new Rectangle;
18 f( s );
19 }
基类中没有虚函数draw，则s->draw()出错。
问题：
1 class Shape {
2 public: virtual void draw();
3 };
4 class Rectangle : public Shape{
5 public:
6 virtual void draw(int a);
7 };
8 class Circle :public Shape {
9 public:
10 virtual void draw();
11 };
12 void f(Shape* s) {
13 s->draw();
14 }
15 int main() {
16 Shape *s = new Rectangle;
17 f( s );
18 Shape *c = new Circle;
19 f( c );
20 }
Rectangle中定义的draw与基类中的虚函数draw不同，则基类中的draw没有被override。
一个函数调用如果在编译时候确定调用哪个函数，我们称它为静态绑定；如果编译时候不能确定，到运行时才能确定，那么我们称它为动态绑定。
一般虚函数使用动态绑定，普通函数使用静态绑定。动态绑定比静态绑定速度慢。
虚表（virtual table）——C++多态的实现方法
虚析构函数作用：通过基类指针来释放派生类对象时，能够保证调用正确的析构函数
更多例子：动物的叫的例子
1 class Animal {
2 public:
3 virtual void shout() { cout << "animal cannot shout"; }
4 };
5 class Dog : public Animal {
6 public:
7 void shout() { cout << “Dog barking!”; }
8 };
9 class Ox : public Animal {
10 public:
11 void shout() { cout << “Ox Moo”; }
12 };
13
14 class Fish: public Animal {
15 //shout not overridden here, Animal::shout is inherited
16 };
17 void f(Animal *a) {
18 a->shout();
19 }
20 int main () {
21 int i; cin >> i;
22 Animal *a;
23 switch(i) {
24 case 1: a = new Dog; break;
25 case 2: a = new Ox; break;
26 case 3: a = new Fish; break;
27 }
28 f(a);
29 delete a;
30 }
10. 纯虚函数和抽象类
问题：某些基类的虚函数没有实现的意义
纯虚函数(pure virtual function)：函数体可以省略的虚函数
抽象类(abstract class)：含有纯虚函数的类称为抽象类。类中只要有一个函数是纯虚函数，这个类就是抽象类。抽象类不能实例化，即不能定义对象。
与抽象类相对的是实体类（concrete class），即不包含纯虚函数的类
抽象类虽然不能够实例化，但可以派生。在派生类中，纯虚函数会被继承。如果在派生类中，给出了所有纯虚函数的实现，那么派生类将成为实体类
1 class Shape { //abstract class
2 public:
3 virtual void draw() =0;
4 virtual double getarea() = 0;
5 };
6 class Rectangle :public Shape {
7 public:
8 virtual void draw() {/*...*/}
9 virtual double getarea() { /*...*/}
10 };
11 class Circle : public Shape{
12 public:
13 virtual void draw() { /*...*/}
14 };
Rectangle为实体类，Circle为抽象类
纯虚函数一般省略函数体，但也可以有函数体
带函数体的纯虚函数可以在派生类中被调用
接口类：只有纯虚函数成员的类。 IUnknown:微软所有COM（Component Object Model）对象的基类
11. 运行时类型信息
问题：某些情况下，光靠多态性不够用，必须得到对象准确的类型信息
两种RTTI机制：dynamic_cast和typeid。先决条件：类中必须有虚函数。在使用RTTI之前，需要先审查在面向对象设计上是否出了问题。
1 dynamic_cast
2 void f(Person *p) {
3 if( dynamic_cast<Student *>(p) ) {
4 cout<<“p is a Student object or its derivation”;
5 Student *s = dynamic_cast<Student *>(p);
6 } else if( dynamic_cast<Teacher *>(p) ) {
7 cout<<“p is a Teacher object or its derivation”;
8 Teacher * t = dynamic_cast<Teacher *>(p);
9 }
10 }
typeid能够确定表达式的确切类型，使用时要包含<typeinfo>
typeid返回一个typeinfo类对象的引用
用法：
12. 面向对象设计方法
- 确定程序中需要的类及每个类需要的操作
- 将不同类的共同的操作提取到基类
- 通过基类接口来操纵各种不同的对象
- 可以通过增加新的派生类来扩展系统
例子：
- 复合文档（composite模式）：包含文字、图形的文档
- 一组数据，有多种表现形式（observer模式）（比如表格、柱状图、柄图）
设计模式：
前人成功经验总结的可以重复利用的面向对象软件设计的范例。用处：套用前人范式以面向对象思想解决问题，设计出健壮、可复用、支持变化的软件。参考书：《设计模式——可复用面向对象软件的基础》——GoF（Erich Gamma等四人）