C++ | 继承（基类，父类，超类），（派生类，子类）

转载：https://blog.csdn.net/Sherlock_Homles/article/details/82927515

文章参考：https://blog.csdn.net/war1111886/article/details/8609957

一 .继承中的访问权限关系

１．基类，父类，超类是指被继承的类，派生类，子类是指继承于基类的类． 

２．在C++中使用： 冒号表示继承，如class A : public B；表示派生类Ａ从基类Ｂ继承而来

３．派生类包含基类的所有成员，而且还包括自已特有的成员，派生类和派生类对象访问基类中的成员就像访问自已的成员一样，可以直接使用，不需加任何操作符，但派生类仍然无法访问基类中的私有成员．

４．在Ｃ++中派生类可以同时从多个基类继承，Java 不充许这种多重继承，当继承多个基类时，使用逗号将基类隔开．

５．基类访问控制符

     class A : public B        基类以公有方式被继承，

     class A:private B        基类以私有方式被继承，

     class A:protected B    基类以受保护方式被继承，如果没有访问控制符则默认为私有继承。

6． protected 受保护的访问权限：使用protected 保护权限表明这个成员是私有的，但在派生类中可以访问基类中的受保护成员。派生类的对象就不能访问受保护的成员了。

7． 如果基类以public公有方式被继承，则基类的所有公有成员都会成为派生类的公有成员．受保护的基类成员成为派生类的受保护成员
      如果基类以private私有被继承，则基类的所有公有成员都会成为派生类的私有成员．基类的受保护成员成为派生类的私有成员． 

      如果基类以protected 受保护方式被继承，那么基类的所有公有和受保护成员都会变成派生类的受保护成员．

     不管基类以何种方式被继承，基类的私有成员，仍然保有其私有性，被派生的子类不能访问基类的私有成员．

例：继承中的访问权限关系

1.  
   class A {
2.  
   int a;
3.  
   protected:
4.  
   int b;
5.  
   public:
6.  
   int c;
7.  
    
8.  
   A() { a = b = c = 1; }
9.  
   };
10.  
     
11.  
    //类B以公有方式从基类A继承
12.  
    class B : public A {
13.  
    public:
14.  
    int d;
15.  
     
16.  
    B() {//a=2; //错误，不能访问基类中的私有成员
17.  
    b = 2; //正确，可以在类中访问基类中的受保护成员，但类的对象不能访问，基类中的受保护成员b在类B中仍然是受保护成员
18.  
    c = d = 2;
19.  
    }
20.  
    }; //基类中的公有成员c在类B中仍然是公有成员
21.  
     
22.  
    //类C以受保护和私有方式从基类A继承。
23.  
    class C : protected A {
24.  
    public:
25.  
    int e;
26.  
     
27.  
    C() {//a=3; //错误，不能访问基类中的私有成员
28.  
    b = c = e = 3;
29.  
    }
30.  
    };//这里基类受保护成员b和公有成员c都成为类C中的受保护成员。
31.  
     
32.  
    class D : private A {
33.  
    public:
34.  
    D()
35.  
    { b = c = 4; }
36.  
    };//基类中的公有和受保护成员都成为了类D中的私有成员。
37.  
     
38.  
    //验证受保护和私有方式继承的访问权限。
39.  
    class C1 : public C {
40.  
    public:
41.  
    C1() { b = c = e = 4; }
42.  
    };//正确;类A中的成员b和c在类C中是以受保护方式被继承的，b和c都成为了类C中的受保护成员。
43.  
     
44.  
    class D1 : public D {
45.  
    public:
46.  
    D1() {//b=5; //错误，在A中受保护的成员b在类D中是以私有方式继承的，这样b就成为了类D中的私有成员，所以无法访问。
47.  
    //c=5; //错误，在A中公有的成员c在类D中是以私有方式继承的，这样c就成为了类D中的私有成员，所以无法访问。
48.  
    }
49.  
    };
50.  
     
51.  
    int main()
52.  
    {
53.  
    A m1;
54.  
    B m2;
55.  
    C m3;
56.  
    D m4;
57.  
    //cout<<m1.b<<m2.b<<m3.b<<m4.b<<endl;  //错误；不能用类的对象访问受保护的成员，只有在类中才能访问。
58.  
    cout << m1.c <<endl;
59.  
    cout << m2.c <<endl;
60.  
    //cout<<m3.c<<endl; //错误，类C是以受保护的方式从A继承的，基类中的变量c在类C中就是受保护的，所以类的对象不能访问
61.  
    //cout<<m4.c<<endl; //错误，类C是以私有的方式从A继承的，基类中的变量c在类C中就是私有的，所以类的对象不能访
62.  
    }

二.覆盖和隐藏基类成员变量或成员函数

1． 基类的成员变量或函数被覆盖：

如果派生类覆盖了基类中的成员函数或成员变量，则当派生类的对象调用该函数或变量时是调用的派生类中的版本，当用基类对象调用该函数或变量时是调用的基类中的版本。

2． 隐藏基类成员函数的情况：

如果在派生类中定义了一个与基类同名的函数，不管这个函数的参数列表是不是与基类中的函数相同，则这个同名的函数就会把基类中的所有这个同名的函数的所有重载版本都隐藏了，这时并不是在派生类中重载基类的同名成员函数，而是隐藏，比如类A中有函数 f (int i , int j)和 f (int i)两个版本，当在从A派生出的类B中定义了基类的 f() 函数版本时，这时基类中的 f (int i)和f (int i , int j)就被隐藏了，也就是说由类B创建的对象比如为m，不能直接访问类A中的f(int i)版本，即使用语句m.f(2)时会发生错误。

3． 怎样使用派生类的对象访问基类中被派生类覆盖或隐藏了的函数或变量：

      3.1． 方法1   使用作用域运算符:: ，在使用对象调用基类中的函数或变量时使用作用域运算符即语句m.A::f(2)，这时就能访问基类中的函数或变量版本。注意，访问基类中被派生类覆盖了的成员变量只能用这种方法
      3.2．方法2   使用using:: , 该方法只适用于被隐藏或覆盖的基类函数，在派生类的类定义中使用语句using 把基类的字包含进来，比如using A::f；就是将基类中的函数f()的所有重载版本包含进来，重载版本被包含到子类之后，这些重载的函数版本就相当于是子类的一部分，这时就可以用派生类的对象直接调用被派生类隐藏了的基类版本，比如m.f(2)，但是使用这种语句还是没法调用基类在派生类中被覆盖了的基类的函数，比如m.f()调用的是派生类中定义的函数f，要调用被覆盖的基类中的版本要使用语句m.A::f()才行。

4． 在派生类的函数中调用基类中的成员变量和函数的方法：

就是在函数中使用的被派生类覆盖的基类成员变量或函数前用作域解析符加上基类的类名，即A::f()就是在派生类的函数中调用基类中被派生类覆盖了的函数f()的方法。

5． 派生类以私有方式被继承时改变基类中的公有成员为公有的方法：

      5.1．使用:: 作用域运算符，不提倡用这种方法，在派生类的public 后面用作用域运算符把基类的公有成员包含进来，这样基类的成员就会成为派生类中的公有成员了，注意如果是函数的话后面不能加括号，如A::f；如果f是函数的话不能有括号。
      5.2．使用using语句，现在一般用这种方法，也是在派生类的public使用using把基类成员包函进来，如using A::f。

例：隐藏或覆盖基类中的成员，使用::作用域运算符访问

1.  
   class A {
2.  
   int a;
3.  
   protected:
4.  
   int b;
5.  
   public:
6.  
   int c, d;
7.  
    
8.  
   void f(int i) {
9.  
   cout << "class A" << " ";
10.  
    }
11.  
     
12.  
    A() { a = b = c = d = 1; }
13.  
    };
14.  
     
15.  
    class B : public A {
16.  
    public:
17.  
    int d;
18.  
    //覆盖基类中的成员变量d。
19.  
    B() {
20.  
    b = c = d = 2; //这里是给子类B中的成员变量d赋值，而不是基类中的d
21.  
    A::d = 3;
22.  
    } //给基类中被覆盖的成员d赋值，注意在类中访问的被覆盖成员的方式。
23.  
    void f() {
24.  
    cout << "class B" << " "; //在子类中重定义基类中的同名函数，虽然参数列表不一样，但同样会隐藏基类中的同名函数
25.  
    A::f(1); //在函数中调用基类中被隐藏了的同名函数的方法，使用作用域解析运算符。
26.  
    //f(1);  //错误，因为基类中的函数被子类中的同名函数隐藏了，在这里子类不知道有一个带参数的函数f。
27.  
    }
28.  
    };
29.  
    int main() {
30.  
    B m;
31.  
    cout << m.d << " "; //输出子类中的成员变量d的值，注意派生类中覆盖了基类成员d.
32.  
    cout << m.A::d << " "; //输出基类中的成员变量d的值，注意这是使用对象访问被覆盖的基类成员的方式
33.  
    m.f(); //调用子类中的不带参数的函数f。
34.  
    // m.f(2);  //错误，因为基类中的带一个参数的函数f被子类中的同名函数隐藏掉了，不能这样访问，须用作用域解析运算符来访问。
35.  
    m.A::f(1);
36.  
    } //使用子类对象访问基类中被隐藏的函数的方法。

例：使用using 语句以便访问基类中被隐藏的函数

1.  
   class A {
2.  
   int a;
3.  
   protected:
4.  
   int b;
5.  
   public:
6.  
   int c, d;
7.  
    
8.  
   void f() { cout << "Amoren" << " "; }
9.  
    
10.  
    void f(int i) { cout << "class A" << " "; }
11.  
     
12.  
    A() { a = b = c = d = 1; }
13.  
    };
14.  
     
15.  
    class B : public A {
16.  
    public:
17.  
    int d;
18.  
    //覆盖基类中的成员变量d。
19.  
    B() {
20.  
    b = c = d = 2; //这里是给类B中的成员变量d赋值，而不是基类中的d
21.  
    A::d = 3;
22.  
    } //给基类中被覆盖的成员d赋值，注意在类中访问的被覆盖成员的方式。
23.  
    using A::f; //使用语句using把类A中的函数f包含进来，以便以后可以直接访问基类被隐藏了的函数，注意函数f没有括号
24.  
     
25.  
    void f() {
26.  
    cout << "class B" << " "; //在子类中覆盖基类中的同名函数，注意这里是覆盖，同时会隐藏基类中的其他同名重载函数
27.  
    f(1); //正确，因为使用了using语句，所以可以在类中直接使用基类中f函数的重载版本。
28.  
    A::f(2); //正确，虽然使用了using语句，但同样可以按这种方法访问基类中的函数。
29.  
    A ma;
30.  
    ma.f(); //正确，在子类中创建的基类对象，可以直接用对象名调用基类中被子类覆盖或隐藏了的函数，因为这时不会出现二义性。
31.  
    ma.f(1); //正确，在子类中创建的基类对象，可以直接用对象名调用基类中被子类覆盖或隐藏了的函数，因为这时不会出现二义性。
32.  
    }
33.  
     
34.  
    void g() {
35.  
    cout << "this g" << " ";
36.  
    f(); //正确，但该语句访问的是子类中的不带参数函数f，虽然在类中使用了using语句，但直接调用被子类覆盖了的基类函数时不能使用这种方法
37.  
    A::f(); //正确，调用被子类覆盖了的基类中的函数f，注意，虽然使用了using但要访问被子类覆盖了的函数，只能这样访问。
38.  
    }
39.  
    };
40.  
    int main() {
41.  
    B m;
42.  
    m.f(); //调用子类中的不带参数的函数，这里不会调用基类中的不带参数的被覆盖的函数f。
43.  
    m.A::f(); //调用基类中被子类覆盖了的函数f，虽然子类使用了using语句，但要访问基类中被覆盖的方法只能像这样使用。
44.  
    m.f(1); //调用基类重载的f函数，注意这里可以不用::运算符，因为在子类中使用了using，只要子类没有覆盖基类中的方法，都可以这样直接调用。
45.  
    m.A::f(2); //当然，使用了using后，也可以使用这种方法
46.  
    }

例：派生类以私有方式被继承时改变基类中的公有成员为公有的方法

1.  
   class A {
2.  
   public:
3.  
   int a, b;
4.  
   void f() { cout << "f" << " "; }
5.  
   void g() { cout << "g" << " "; }
6.  
   };
7.  
    
8.  
   class B : private A {
9.  
   public:
10.  
    A::f; //使用::运算符使基类中的成员成为公有的。注意函数名后不能有括号。(C++11标准不允许，使用using A::f)
11.  
    A::a; //(C++11标准不允许，使用using A::a)
12.  
    using A::g; //使用using语句使基类中的成员函数g成为类B中的公有成员，注意函数名后不能有括号。
13.  
    };
14.  
    int main() {
15.  
    B m;
16.  
    //m.b=1;  //错误，因为类B是以私有方式继承的，类A中的成员在类B中是私有的，这里不能访问私有成员。
17.  
    m.f();
18.  
    m.g();
19.  
    m.a = 1;
20.  
    }

三.继承时的构造函数和析构函数问题

1． 在继承中，基类的构造函数构建对象的基类部分，派生类的构造函数构建对象的派生类部分。

2． 当创建派生类对象时先用派生类的构造函数调用基类的构造函数构建基类，然后再执行派生类构造函数构造派生类。
即先构造基类再构造派生类的顺序。执行析构函数的顺序与此相反。

3． 调用基类带参数的构造函数的方法：

在派生类的构造函数中使用初始化列表的形式就可以调用基类带参数的构造函数初始化基类成员，如B():A(int i){}，类B是类A的派生类。

4． 派生类的构造函数调用基类的构造函数的方法为：

4.1 如果派生类没有显示用初始化列表调用基类的构造函数时，这时就会用派生类的构造函数调用基类的默认构造
函数，构造完基类后，才会执行派生类的构造函数函数体，以保证先执行基类构造函数再执行派生类构造函数
的顺序，如果基类没有默认构造函数就会出错。
4.2 如果派生类用 显示的初始化列表调用基类的构造函数时，这时就会检测派生类的初始化列表，当检测到显示调
用基类的构造函数时，就调用基类的构造函数构造基类，然后再构造派生类，以保证先执行基类构造函数再执
行派生类构造函数的顺序，如果基类没有定义派生类构造函数初始化列表调用的构造函数版本就会出错。

5． 如果在基类中没有定义默认构造函数，但定义了其他构造函数版本，这时派生类中定义了几个构造函数的不同版本，
这时只要派生类有一个构造函数没有显示调用基类中定义的构造函数版本就会发生错误，因为编译器会首先检查派
生类构造函数调用基类构造函数的匹配情况，如果发现不匹配就会出错，即使没有创建任何类的对象都会出错，而
不管这个派生类的对象有没有调用派生类的这个构造函数。比如：基类有一个构造函数版本A(int i)而没有定义默认
构造函数，派生类B，有这几个版本的构造函数B():A(4){}，B(int i):A(5){}，再有语句B(int i, int j){}没有显示调用
基类定义的构造函数而是调用基类的默认构造函数，如果创建了B m和语句B m(1)时都会提示没有可用的基类默认
构造函数可用的错误，虽然这时类B的对象m没有调用派生类B的带有两个形参的构造函数，但同样会出错。

6． 同样的道理，如果基类中定义了默认构造函数，却没有其他版本的构造函数，而这时派生类却显示调用了基类构造
函数的其他版本，这时就会出错，不管你有没有创建类的对象，因为编译器会先在创建对象前就检查构造函数的匹
配问题。

7． 派生类只能初始化他的直接基类。比如类C是类B的子类，而类B又是类A的子类，这时class C:public B{public:
B():A(){} };将会出错，该语句试图显示调用类B的基类类A的构造函数，这时会出现类A不是类C的基类的错误。

8． 继承中的复制构造函数和构造函数一样，基类的复制构造函数复制基类部分，派生类的复制构造函数复制派生类部
分。

9．派生类复制构造函数调用基类复制构造函数的方法为：A(const A& m):B(m){}其中B是基类，A是派生类。

10．如果在派生类中定义了复制构造函数而没有用初始化列表显示调用基类的复制构造函数，这时不管基类是否定义了
复制构造函数，这时出现派生类对象的复制初始化情况时就将调用基类中的默认构造函数初始化基类的成员变量，
注意是默认构造函数不是默认复制构造函数，如果基类没有默认构造函数就会出错。也就是说派生类的复制构造函
数的默认隐藏形式是B(const B& j):A(){}这里B是A的派生类，也就是说如果不显示用初始化列表形式调用基类的
复制构告函数时，默认情况下是用初始化列表的形式调用的是基类的默认构造函数。

11．当在派生类中定义了复制构造函数且显示调用了基类的复制构造函数，而基类却没有定义基类的复制构造函数时，
这时出现派生类对象的复制初始化情况就将调用基类中的默认复制构造函数初始化基类部分，调用派生类的复制构
造函数初始化派生类部分，因为复制构造函数只有一种形式，即A(const A& m){}，比如当出现调用时A(const A&
m):B(m){}如果这时基类B没有定义复制构造函数，则该语句将会调用派生类A的默认复制构造函数。

12．如果基类定义了复制构造函数，而派生类没有定义时，则会调用基类的复制构造函数初始化基类部分，调用派生类
的默认复制构造函数初始化派生类部分。