5.6-day06-C++继承与多态/多重继承/私有继承和保护/虚函数与多态

五、关于操作符重载的限制

1.至少有一个操作数是类类型的。

int a = 10, b = 20;

int c = a + b; // 200

int operator+ (int a, int b) {

  return a * b;

} // ERROR !

2.不是所有的操作符都能重载。

:: - 作用域限定

.  - 直接成员访问

.* - 直接成员指针解引用

?: - 三目运算符

sizeof - 获取字节数

typeid - 获取类型信息

3.不是所有的操作符都可以用全局函数的方式实现。

=  - 拷贝赋值

[] - 下标

() - 函数

-> - 间接成员访问

4.不能发明新的操作符。

x ** y; // x^y

#

@

第四课  继承与多态

一、继承的基本概念

人类：姓名、年龄、吃饭

学生是人：学号、学习

教师是人：工资、讲课

    人类      - 基类，共性

   /    \       派生V^继承

学生     教师 - 子类，个性

二、继承的语法

class 子类名 : 继承方式1 基类1, 继承方式2 基类2, ... {

  ...

};

继承方式：

公有继承 - public - 最常用方式

私有继承 - private - 缺省方式

保护继承 - protected - 特殊的私有继承

三、公有继承

1.通过继承，在基类中定义的任何成员，也都成为了子类的成员，但是基类的私有成员，子类虽然拥有却不能直接访问。

2.基类中的保护成员，可以被子类直接访问，但不能在无关的类和全局域中被访问。

3.任何一个子类对象中都包含着它的基类子对象。如果在子类的构造函数中没有明确指明其基类子对象如何被构造，系统将采用无参的方式构造该子对象。如果在初始化表中指明了基类子对象的构造方式，就调用相应的构造函数构造该子对象。

4.子类对象的构造和析构顺序

按照继承表的顺序依次构造每个基类子对象->按照声明的顺序依次构造每个成员变量->执行子类构造函数体中的代码

析构的过程与构造严格相反

5.一个子类对象在任何都可以被视为它的基类对象——IsA。

任何时候，一个子类对象的指针或者引用，都可以被隐式地转换为它的基类类型的指针或者引用，但是反过来，将基类类型的指针或者引用转换为它的子类类型必须显示地(static_cast)完成。

Student s (...);

Human* h = &s; // OK !

6.在子类中定义的任何和基类成员同名的标识符，都可以将基类中的该成员隐藏起来。通过作用域限定操作符“::”，可对该成员解隐藏。

四、继承方式对访控属性的影响

class A {

X:

   void foo (void) { ... }

};

class B : Y A {

  void bar (void) {

    foo (); // 仅需考虑X

  }

};

int main (void) {

  B b (...);

  b.foo(); // 不仅要考虑X还要考虑Y

}

class C : Z B {

  void fun (void) {

    foo(); // 不仅要考虑X还要考虑Y

  }

};

当通过一个子类对象(B)访问它从基类(A)中继承过来的成员(foo)的时候，需要考虑子类(B)从基类(A)继承时所采用的继承方式。

1.访控属性

关键字    属性 基类 子类 外部 友员

public    公有  OK   OK   OK   OK

protected 保护  OK   OK   NO   OK

private   私有  OK   NO   NO   OK

2.基类的成员被继承到子类中以后，其访控属性会因不同的继承方式而异。

基类 公有继承 保护继承 私有继承

公有 公有     保护     私有

保护 保护     保护     私有

私有 私有     私有     私有

五、子类的构造函数和析构函数

1.子类隐式地调用基类的构造函数

在子类的构造函数中没有显示地指明其基类部分如何构造，隐式地调用基类的无参构造函数。如果子类没有定义任何构造函数，其缺省无参构造函数同样会隐式地调用基类的无参构造函数。

2.子类显式地调用基类的构造函数

在子类构造函数的初始化表中指明其基类部分的构造方式。

class A {

public:

  A (void) : m_data (0) {}

  A (int data) : m_data (data) {}

private:

  int m_data;

};

class B : public A {

public:

  B (int data) : A (data) {}

};

3.继承链的构造和初始化顺序

class A { ... };

class B : public A { ... };

class C : public B { ... };

C c (...);

构造：A->B->C

析构：C->B->A

任何时候子类中基类子对象的构造都要先于子类构造函数中的代码。

4.delete一个指向子类对象的基类指针，实际被执行的基类的析构函数，基类的析构函数不会调用子类析构函数，因此子类所特有的资源将形成内存泄漏。

Human* p = new Student (...);

delete p; // ->Human::~Human()

delete static_cast<Student*> (p);

六、子类的拷贝构造和拷贝赋值

子类的缺省拷贝构造和拷贝赋值除了复制子类的特有部分以外，还会复制其基类部分。如果需要自己定义子类的拷贝构造和拷贝赋值，一定不要忘记在复制子类特有部分的同时，也要复制其基类部分，否则将无法得到完整意义上的对象副本。

七、私有继承和保护继承

用于防止或者限制基类中的公有接口被从子类中扩散。

class DCT {

public:

  void codec (void) { ... }

};

class Jpeg : protected DCT {

public:

  void render (void) {

    codec (...);

  }

};

Jpeg jpeg;

jpeg.codec (...); // ERROR !

Jpeg Has A DCT，实现继承

class Jpeg2000 : public Jpeg {

public:

  void render (void) {

    codec (...); // OK !

  }

};

八、多重继承

从多于一个基类中派生子类。

电话 媒体播放器 计算机

    \    |     /

      智能手机  

1.多重继承的语法和语义与单继承并没有本质的区别，只是子类对象中包含了更多的基类子对象。它们在内存中按照继承表的先后顺序从低地址到高地址依次排列。

2.子类对象的指针可以被隐式地转换为任何一个基类类型的指针。无论是隐式转换，还是静态转换，编译器都能保证特定类型的基类指针指向相应类型基类子对象。但是重解释类型转换，无法保证这一点。

3.尽量防止名字冲突。

4.钻石继承和虚继承

1)钻石继承

  A

 / \

B   C

 \ /

  D

class A { ... };

class B : public A { ... };

class C : public A { ... };

class D : public B,public C{ ...};

在最终子类(D)对象中存在公共基类(A)子对象的多份实例，因此沿着不同的继承路径访问公共基类子对象中的成员，会发生数据不一致的问题。

2)虚继承

在继承表中通过virtual关键字指定从公共基类中虚继承，这样就可以保证在最终子类对象中，仅存在一份公共基类子对象的实例，避免沿着不同的继承路径访问公共基类子对象中的成员时，所引发的数据不一致的问题。

只有当所创建对象的类型回溯(su)中存在钻石结构时，虚继承才起作用，否则编译器会直接忽略virtual关键字。

    图形：位置，绘制

    /        \

矩形：宽和高  圆：半径

      绘制        绘制

九、虚函数与多态

如果将基类中的一个成员函数声明为虚函数，那么子类中的同型函数就也成为虚函数，并且对基类版本形成覆盖。这时，通过一个指向子类对象的基类指针，或者一个引用子类对象的基类引用，调用该虚函数时，实际被调用的函数不由该指针或引用的类型决定，而由它们的目标对象决定，最终导致子类中覆盖版本被执行。这种现象称为多态。

十、函数覆盖的条件

overload - 重载

override - 覆盖、重写、改写

1.基类版本必须是虚函数。

2.函数名、形参表和常属性必须严格一致。

3.如果返回基本类型或者对象，那么也必须严格一致。如果返回类类型的指针或引用，那么子类版本也可以返回基类版本的子类。

class B : public A { ... };

基类：virtual A* foo (void) {...}

子类：A* foo (void) { ... }

      B* foo (void) { ... }

4.子类的覆盖版本不能比基类版本声明更多的异常抛出。

5.子类覆盖版本的访控属性与基类无关。

class A {

public:

  virtual void foo (void) { ... }

};

class B : public A {

private:

  void foo (void) { ... }

};

int main (void) {

  B* b = new B;

  b->foo (); // ERROR !

  A* a = new B;

  a->foo (); // OK ! -> B::foo

}

十一、多态=虚函数+指针/引用

Rect rect (...);

Shape shape = rect;

shape->draw (); // Shape::draw

Shape& shape = rect;

shape->draw (); // Rect::draw

class A {

public:

  A (void) {

    bar (); // A::bar

  }

  ~A (void) {

    bar (); // A::bar

  }

  void foo (void) {

    this->bar (); // B::bar

  }

  virtual void bar (void) {

    cout << 'A' << endl;

  }

};

class B : public A {

  void bar (void) {

    cout << 'B' << endl;

  }

};

int main (void) {

  B b; // A

  b.foo (); // B

  return 0;

}

---

diamond.cpp

1. #include<iostream>
2. usingnamespace std;
3. class A {
4. public:
5. A (int i): m_i (i){}
6. protected:
7. int m_i;
8. };
9. class B :virtualpublic A {
10. public:
11. B (int i): A (i){}
12. voidset(int i){
13. m_i = i;
14. }
15. };
16. class C :virtualpublic A {
17. public:
18. C (int i): A (i){}
19. int get (void){
20. return m_i;
21. }
22. };
23. class D :public B,public C {
24. public:
25. D (int i): B (i), C (i), A (i){}
26. };
27. int main (void){
28. D d (1000);
29. cout << d.get ()<< endl;// 1000
30. d.set(2000);
31. cout << d.get ()<< endl;// 2000
32. return0;
33. }

 

在最终子类D对象中存在公共基类A子对象的多份实例，因此沿着不同的继承路径访问公共基类子对象中的成员，会发生数据不一致的问题。

 

通过虚继承解决数据不一致的问题；

共享一个A，产生这样一个共享内存的结构。

公共基类也需要用i去初始化。

 

---

human.cpp

1. #include<iostream>
2. usingnamespace std;
3. classHuman{
4. public:
5. Human(const string& name,int age):
6. m_name (name), m_age (age){}
7. void who (void)const{
8. cout << m_name <<"，"<< m_age << endl;
9. }
10. void eat (const string& food)const{
11. cout <<"我在吃"<< food << endl;
12. }
13. protected:
14. string m_name;
15. int m_age;
16. };
17. classStudent:publicHuman{
18. public:
19. Student(const string& name,int age,int no):
20. Human(name, age), m_no (no){}
21. Student(constStudent& that):
22. Human(that), m_no (that.m_no){}
23. Student&operator=(constStudent& that){
24. if(&that !=this){
25. Human::operator=(that);
26. m_no = that.m_no;
27. }
28. return*this;
29. }
30. void learn (const string& lesson)const{
31. cout <<"我("<< m_name <<"，"<< m_age
32. <<"，"<< m_no <<")在学"<< lesson
33. << endl;
34. }
35. usingHuman::eat;
36. void eat (void)const{
37. cout <<"我绝食！"<< endl;
38. }
39. // int eat;
40. private:
41. int m_no;
42. };
43. int main (void){
44. Student s1 ("张飞",25,1001);
45. s1.who ();
46. s1.eat ("包子");
47. s1.learn ("C++");
48. Human* h1 =&s1;
49. h1 -> who ();
50. h1 -> eat ("KFC");
51. // h1 -> learn ("C");
52. Student* ps =static_cast<Student*>(h1);
53. ps -> learn ("C");
54. Student s2 = s1;
55. s2.who ();
56. s2.learn ("英语");
57. Student s3 ("赵云",20,1002);
58. s3 = s2;
59. s3.who ();
60. s3.learn ("数学");
61. return0;
62. }

 using 为作用域声明，形成重载关系。

 

 任何时候，一个子类对象的指针或者引用，都可以被隐式地转换为它的基类类型的指针或者引用；但是，反过来，将基类类型的指针或者引用转换为它的子类类型必须显示地（static_cast）完成。

 

---

shape.cpp

1. #include<iostrea
2. usingnamespace std;
3. classShape{
4. public:
5. Shape(int x,int y): m_x (x), m_y (y){}
6. virtualvoid draw (void){
7. cout <<"形状("<< m_x <<','<< m_y <<')'
8. << endl;
9. }
10. protected:
11. int m_x, m_y;
12. };
13. classRect:publicShape{
14. public:
15. Rect(int x,int y,int w,int h):
16. Shape(x, y), m_w (w), m_h (h){}
17. void draw (void){
18. cout <<"矩形("<< m_x <<','<< m_y <<','
19. << m_w <<','<< m_h <<')'<< endl;
20. }
21. private:
22. int m_w, m_h;
23. };
24. classCircle:publicShape{
25. public:
26. Circle(int x,int y,int r):
27. Shape(x, y), m_r (r){}
28. void draw (void){
29. cout <<"圆形("<< m_x <<','<< m_y <<','
30. << m_r <<')'<< endl;
31. }
32. private:
33. int m_r;
34. };
35. void render (Shape* shapes[]){
36. for(size_t i =0; shapes[i];++i)
37. shapes[i]->draw ();
38. }
39. int main (void){
40. Shape* shapes[1024]={};
41. shapes[0]=newRect(1,2,3,4);
42. shapes[1]=newCircle(5,6,7);
43. shapes[2]=newCircle(8,9,10);
44. shapes[3]=newRect(11,12,13,14);
45. shapes[4]=newRect(15,16,17,18);
46. render (shapes);
47. return0;
48. }

 

 

 函数覆盖的条件：

overload - 重载

override - 覆盖、重写、改写

1.基类版本必须是虚函数。

2.函数名、形参表和常属性必须严格一致。

3.如果返回基本类型或者对象，那么也必须严格一致。如果返回类类型的指针或引用，那么子类版本也可以返回基类版本的子类。

class B : public A { ... };

基类：virtual A* foo (void) {...}

子类：A* foo (void) { ... }

      B* foo (void) { ... }

 

---

 

smartphone.cpp

1. #include<iostream>
2. usingnamespace std;
3. classPhone{
4. public:
5. Phone(const string& numb): m_numb (numb){}
6. void call (const string& numb){
7. cout << m_numb <<"致电"<< numb << endl;
8. }
9. void foo (void){
10. cout <<"Phone::foo"<< endl;
11. }
12. private:
13. string m_numb;
14. };
15. classPlayer{
16. public:
17. Player(const string& media): m_media (media){}
18. void play (const string& clip){
19. cout << m_media <<"播放器播放"<< clip
20. << endl;
21. }
22. void foo (int data){
23. cout <<"Player::foo"<< endl;
24. }
25. private:
26. string m_media;
27. };
28. classComputer{
29. public:
30. Computer(const string& os): m_os (os){}
31. void run (const string& prog){
32. cout <<"在"<< m_os <<"上运行"<< prog
33. << endl;
34. }
35. private:
36. string m_os;
37. };
38. classSmartPhone:publicPhone,publicPlayer,
39. publicComputer{
40. public:
41. SmartPhone(const string& numb,
42. const string& media,const string& os):
43. Phone(numb),Player(media),
44. Computer(os){}
45. usingPhone::foo;
46. usingPlayer::foo;
47. };
48. int main (void){
49. SmartPhone sp ("13910110072","MP3","Android");
50. sp.call ("01062332018");
51. sp.play ("High歌");
52. sp.run ("愤怒的小鸟");
53. Phone* p1 =reinterpret_cast<Phone*>(&sp);
54. Player* p2 =reinterpret_cast<Player*>(&sp);
55. Computer* p3 =reinterpret_cast<Computer*>(&sp);
56. cout <<&sp <<' '<< p1 <<' '<< p2 <<' '
57. << p3 << endl;
58. sp.foo ();
59. sp.foo (100);
60. return0;
61. }

 多重继承：从多于一个基类中派生子类。

 

  把相关的基类子针指向相应类型基类子对象；

  重解释类型转换，机械地把一种类型转化为另一种类型；

  只管类型不管值，值不该。

 

 

 

 

 

 

 

 

 

 

 

<wiz_tmp_tag id="wiz-table-range-border" contenteditable="false" style="display: none;">

 

 

 

 

来自为知笔记(Wiz)