继承

一.子类不继承父类构造函数，析构函数，默认私有继承或protected

二.using声明可在子类把父类成员改为私有

 1 class B
 2 {
 3 public:
 4     void set(){}
 5 };
 6 
 7 class C: public B
 8 {
 9 private:
10     using B::set;
11 };

三.派生类成员与父类成员名字相同，会发生名字隐藏

 1 #include <iostream>
 2 #include <string>
 3 using namespace std;
 4 
 5 class B
 6 {
 7 public:
 8     void h(float x){}
 9 };
10 
11 class C: public B
12 {
13 public:
14     void h(string s){}
15 };
16 
17 int main()
18 {
19     C c;
20     c.h("abc");//ok
21     c.h(1.7);//error
22     c.B::h(1.7);//ok
23     return 0;
24 }

四.派生类可对从基类继承来的保护成员进行访问，也就是说保护成员在派生类中是可见的

派生类不能访问一个基类对象的保护乘员，因为基类对象属于基类，不属于派生类

派生类中的派生类可访问基类的保护乘员，因为派生类对象属于派生类

 1 #include <iostream>
 2 #include <string>
 3 using namespace std;
 4 
 5 class B
 6 {
 7 protected:
 8     int get_W() const { return 0; }
 9 };
10 
11 class C: public B
12 {
13 public:
14     int get_V()const { return get_W(); }
15     void base_W(const B &b) const { cout << b.get_W() << endl; }//error
16     void p(C &c)const { cout << c.get_W() << endl; } // OK
17 
18 };
19 
20 int main()
21 {
22     C c;
23     c.getW(); //error, protected
24     return 0;
25 }

应避免将数据成员设置成protected，而应采用私有或者相应保护类型访问函数

五.创建派生类时，父类默构自动调用。父类若有带参构造，则必须有自定义默构，除非显示调用基类带参构造。

 1 #include <iostream>
 2 #include <string>
 3 using namespace std;
 4 
 5 class Base
 6 {
 7 public:
 8     Base(int m, int n)
 9     {
10         x = m;
11         y = n;
12     }
13 private:
14     int x, y;
15 };
16 
17 class Derived: public Base
18 {
19 public:
20     Derived(int m, int n, int k):Base(m, n)
21     {
22         z = k;
23     }
24 private:
25     int z;
26 };
27 
28 int main()
29 {
30     Derived d(1, 2, 3);
31     return 0;
32 }

 1 #include <iostream>
 2 #include <string>
 3 using namespace std;
 4 
 5 class Base
 6 {
 7 public:
 8     Base(int m, int n)
 9     {
10         x = m;
11         y = n;
12     }
13 private:
14     int x, y;
15 };
16 
17 class Derived: public Base
18 {
19 public:
20     Derived(int k)
21     {
22         z = k;
23     }
24 private:
25     int z;
26 };
27 
28 int main()
29 {
30     Derived d(3);//error, Base没有合适的默认构造函数可用
31     return 0;
32 }

1.最先调用基类的构造函数，对基类数据成员初始化顺序取决于被继承时的说明顺序；

2.再调用数据成员是类对象的构造函数，顺序按类中定义的先后顺序；

3.最后执行派生类构造函数；

4.析构函数的调用与构造函数正好相反，由于每个类至多只有一个析构函数，调用时不会产生二义性。

六.多重继承机制下的命名冲突

 1 #include <iostream>
 2 #include <string>
 3 using namespace std;
 4 
 5 class A
 6 {
 7 public:
 8     void f();
 9 };
10 
11 class B
12 {
13 public:
14     void f();
15     void g();
16 };
17 
18 class C: public A, public B
19 {
20 public:
21     void h();
22     void g();
23 };
24 
25 int main()
26 {
27     C c;
28     c.g();//c中g()，B中被重写
29     c.f();//error，无法确定,若B:public A则c.f()不会产生二义性
30 
31     c.B::g();
32     c.A::f();
33     c.B::f();
34     return 0;
35 }

 1 #include <iostream>
 2 #include <string>
 3 using namespace std;
 4 
 5 class B
 6 {
 7 public:
 8     int b;
 9 };
10 
11 class B1:public B
12 {};
13 
14 class B2:public B
15 {};
16 
17 class C: public B1, public B2
18 {};
19 
20 int main()
21 {
22     C c;
23     c.b;//error，b不明确
24     c.B::b;//B不明确，在VS2015中默认为B1中的B的b
25     /*
26     C->B1->B->b
27      ->B2->B->b
28      基类对象B在派生类C中存储2份
29     */
30     return 0;
31 }

在多条继承路径上有一个公共基类，希望只存储一个公共基类时，可利用虚基类。

 1 #include <iostream>
 2 #include <string>
 3 using namespace std;
 4 
 5 class B
 6 {
 7 public:
 8     int b;
 9 };
10 
11 class B1: virtual public B
12 {
13 public:
14     int b1;
15 };
16 
17 class B2: virtual public B
18 {
19 public:
20     int b2;
21 };
22 
23 class C: public B1, public B2
24 {
25 public:
26     int c;
27 };
28 
29 int main()
30 {
31     C c;
32     c.B1::b = 1;
33     c.B2::b = 2;
34     cout << c.B1::b << endl; // 2 没有同时2个virtual则为1，存储了2个B
35     cout << c.B2::b << endl; // 2
36     /*
37         B1
38      C->  ->B
39         B2
40     C中b值只存储了一份
41     */
42     return 0;
43 }

虚基类的构造函数先于非虚基类执行

虚基类由最派生类（最后一个派生类）调用构造函数初始化

  1 #include <iostream>
  2 #include <string>
  3 using namespace std;
  4 
  5 class A
  6 {
  7 public:
  8     A()
  9     {
 10         cout << "A" << endl;
 11     }
 12     ~A()
 13     {
 14         cout << "~A" << endl;
 15     }
 16 };
 17 
 18 class B: public A
 19 {
 20 public:
 21     B()
 22     {
 23         cout << "B" << endl;
 24     }
 25     ~B()
 26     {
 27         cout << "~B" << endl;
 28     }
 29     int b;
 30 };
 31 
 32 class B3
 33 {
 34 public:
 35     B3()
 36     {
 37         cout << "B3" << endl;
 38     }
 39     ~B3()
 40     {
 41         cout << "~B3" << endl;
 42     }
 43     int b3;
 44 };
 45 
 46 class B1: public B3, virtual public B
 47 {
 48 public:
 49     B1()
 50     {
 51         cout << "B1" << endl;
 52     }
 53     ~B1()
 54     {
 55         cout << "~B1" << endl;
 56     }
 57     int b1;
 58 };
 59 
 60 class B2: virtual public B
 61 {
 62 public:
 63     B2()
 64     {
 65         cout << "B2" << endl;
 66     }
 67     ~B2()
 68     {
 69         cout << "~B2" << endl;
 70     }
 71     int b2;
 72 };
 73 
 74 class D
 75 {
 76 public:
 77     D()
 78     {
 79         cout << "D" << endl;
 80     }
 81     ~D()
 82     {
 83         cout << "~D" << endl;
 84     }
 85     int c;
 86 };
 87 
 88 
 89 class E
 90 {
 91 public:
 92     E()
 93     {
 94         cout << "E" << endl;
 95     }
 96     ~E()
 97     {
 98         cout << "~E" << endl;
 99     }
100     int c;
101 };
102 
103 class C: public B1, public B2
104 {
105 public:
106     C()
107     {
108         cout << "C" << endl;
109     }
110     ~C()
111     {
112         cout << "~C" << endl;
113     }
114     int c;
115     D d; E e;
116 };
117 
118 int main()
119 {
120     C c;
121     return 0;
122 }

七.继承方式

1.公有继承：基类成员公有和保护在派生类中保持原有访问属性，私有成员仍为基类私有；

2.私有继承：基类公有和保护在派生类中成私有成员，私有成员仍为基类私有；

3.受保护继承：基类公有和保护在派生类中成保护成员，私有成员仍为基类私有。保护成员：不能被外界访问，但可被派生类成员访问

八.对基类对象操作的函数，可以对子类的对象进行操作，不可逆

1.派生类对象可以赋值给基类：Base b; Derived d; b = d;

2.Derived d; Base &b = d;初始化基类引用

3.子类地址赋值给基类指针Derived d; Base *b = &d；

必须是public继承关系，protected和private不成立