034-C++之继承

moc

1、概念
继承：我们依据已有的一个类来定义一个类，这使得创建和维护一个应用程序变得更容易，也可以达到了重用代码功能和提高执行时间的效果。
        已有的类称为基类或父类，新建的类称为派生类或子类。
        继承代表了 is a 关系。例如，哺乳动物是动物，狗是哺乳动物，因此，狗是动物，等等。

类访问级别的设置原则：
        1.需要被外界访问的成员直接设置为public；
        2.只能在当前类的内部访问，既不能在类的外部也不能在子类的内部访问的成员的设置为private；
        3.只能在当前类的内部和子类的内部访问的访问的成员设置为protected;

继承方式对子类访问的影响：
        1.public继承：父类成员在子类中保持原有的访问级别；
        2.private继承： 父类所有成员在子类中均变为private；
        3.protected继承：父类private成员在子类中仍为private，public和protected都变为protected。
注意：不管是哪种继承方式，子类都会继承父类的私有成员，但是子类无法访问从父类继承的私有成员。
总结：不同的继承方式会改变继承成员的访问属性。


继承中的父子关系：
        1.子类拥有父类的所有成员变量和成员函数
        2.子类是一种特殊的父类（赋值兼容性原则）
        3.子类对象可以当父类对象使用
        4.子类可以拥有父类没有的方法和属性

判断继承成员是否可访问三要素：
        1 看访问父类的属性（函数）是在子类的内部还是外部
        2 看子类如何从父类继承的（public， protected， private）
        3 看在父类中的访问权限

2、继承中的重名成员与静态成员
        子类中可以定义于父类同名的成员或方法，在子类中访问同名的成员或方法时，会屏蔽掉父类中的成员。
        如果想在子类中使用父类的同名成员或方法，需要显示的使用类的限定符：    类名::成员

1. class base
   
2. {
   
3. public:
   
4.         int a, b;   
   
5. };
   
6. class derived:public base.
   
7. {
   
8. public:
   
9.         int b, c;
   
10. };
    
11. void f()
    
12. {
    
13.         derived d;
    
14.         cout << d.b << d.base::b << endl;
    
15. }

复制代码

静态成员：
        父类定义的静态成员，将被所有的子类共享，即内存中只有一个，所有类和对象共享。
        静态成员的访问特性和普通成员一致；
        子类继承的静态成员同样有两种访问方式，子类名::静态成员    对象名.静态成员

3、继承中的构造和析构
        1、父类的属性，应该有父类的构造函数去初始化；
        2、子类新增加的属性，应该有子类的构造函数完成。
混搭中的构造与析构：
        先构造的父类（从顶至下），在构造包含的类（按定义顺序），最后构造自己，析构方向与之相反，先构造后析构。

1. #include<iostream>
   
2. using std::cout;
   
3. using namespace std;
   
4. 
   
5. class Object
   
6. {
   
7. public:
   
8.         Object(const char* s)
   
9.         {
   
10.                 cout<< "Object()" << "  " << s << endl;
    
11.         }
    
12.         ~Object()
    
13.         {
    
14.                 cout<< "~Object()" << endl;
    
15.         }
    
16. };
    
17. 
    
18. class Parent:public Object
    
19. {
    
20. public:
    
21.         Parent(const char* s):Object(s)   // 先调用父类的构造函数在掉自己的
    
22.         {
    
23.                 cout<< "Parent()" << "  " << s << endl;
    
24.         }
    
25.         ~Parent()
    
26.         {
    
27.                 cout<< "~Parent()" << endl;
    
28.         }
    
29. };
    
30. 
    
31. class Child:public Parent
    
32. {
    
33. public:
    
34.         Child(): o2("o2"), o1("o1"), Parent("Parameter from Child!")
    
35.         {
    
36.                 cout<< "Child()" << endl;
    
37.         }
    
38.         ~Child()
    
39.         {
    
40.                 cout<< "~Child()" << endl;
    
41.         }
    
42. protected:
    
43.         Object o1;
    
44.         Object o2;
    
45. };
    
46. 
    
47. void run()
    
48. {
    
49.         Child child;
    
50. }
    
51. int main()
    
52. {
    
53.         run();
    
54.         system("pause");
    
55.         return 0;
    
56. }

复制代码

4、多继承与虚基类
        一个类可以从多个基类继承来，这种继承关系即多继承。
如果一个子类从多个父类继承，而这些父类又有一个共同的父类，则在对该共同的父类中声明的名字进行访问时，会产生二义性。
原因是：子类通过不同的路径对同一个父父类进行了多次继承。如果要避免这种多次继承，需要在公共的父类的子类继承该父类时前面加virtual，使之成为虚基类。
例：

1. class B {public: int b;};
   
2. class B1: virtual public B {private: int b1;};
   
3. class B2: virtual public B {private: int b2;};
   
4. class C: public B1, public B2 {private: float d; };
   
5. C cc;
   
6. cout << cc.b;    // OK

复制代码

5、类之间的关系
1. has-A
        包含关系，即在新定义的类中，有类成员是其他的已有的类。
2. uses-A
        使用关系，弱关系；一个类部分的使用另外一个类，通过类中的成员关联（做成员函数的参数），定义友元等。
3. is-A
        继承，父子关系，这种关系具有传递性，但不具有对称性。