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

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

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

1.基类,父类,超类是指被继承的类,派生类,子类是指继承于基类的类.

2.在C++中使用: 冒号表示继承,如class A : public B;表示派生类A从基类B继承而来

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

4.在C++中派生类可以同时从多个基类继承,Java 不充许这种多重继承,当继承多个基类时,使用逗号将基类隔开.

5.基类访问控制符

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" << "\n";
  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" << "\n"; //在子类中重定义基类中的同名函数,虽然参数列表不一样,但同样会隐藏基类中的同名函数
  25.  
    A::f(1); //在函数中调用基类中被隐藏了的同名函数的方法,使用作用域解析运算符。
  26.  
    //f(1);  //错误,因为基类中的函数被子类中的同名函数隐藏了,在这里子类不知道有一个带参数的函数f。
  27.  
    }
  28.  
    };
  29.  
    int main() {
  30.  
    B m;
  31.  
    cout << m.d << "\n"; //输出子类中的成员变量d的值,注意派生类中覆盖了基类成员d.
  32.  
    cout << m.A::d << "\n"; //输出基类中的成员变量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" << "\n"; }
  9.  
     
  10.  
    void f(int i) { cout << "class A" << "\n"; }
  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" << "\n"; //在子类中覆盖基类中的同名函数,注意这里是覆盖,同时会隐藏基类中的其他同名重载函数
  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" << "\n";
  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" << "\n"; }
  5.  
    void g() { cout << "g" << "\n"; }
  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.如果基类定义了复制构造函数,而派生类没有定义时,则会调用基类的复制构造函数初始化基类部分,调用派生类
的默认复制构造函数初始化派生类部分。

C++ | 继承(基类,父类,超类),(派生类,子类)的更多相关文章

  1. C++继承具体解释之二——派生类成员函数具体解释(函数隐藏、构造函数与兼容覆盖规则)

    在这一篇文章開始之前.我先解决一个问题. 在上一篇C++继承详解之中的一个--初探继承中,我提到了在派生类中能够定义一个与基类成员函数同名的函数,这样派生类中的函数就会覆盖掉基类的成员函数. 在谭浩强 ...

  2. 3.3 C++改变基类成员在派生类中的访问属性

    参考:http://www.weixueyuan.net/view/6360.html 总结: 使用using声明可以改变基类成员在派生类中的访问属性. private: using book::se ...

  3. C++:调整基类成员在派生类中的访问属性的其他方法(同名成员和访问声明)

    4.3 调整基类成员在派生类中的访问属性的其他方法 4.3.1 同名函数 在定义派生类的时候,C++语言允许在派生类中说明的成员与基类中的成员名字相同,也就是 说,派生类可以重新说明与基类成员同名的成 ...

  4. c#序列化基类(包含派生类继承DynamicObject和 IXmlSerializable)对象

    直接上代码 using System.Diagnostics; using System.Text; using System.Xml; using System.Xml.Schema; using ...

  5. 不可或缺 Windows Native (21) - C++: 继承, 组合, 派生类的构造函数和析构函数, 基类与派生类的转换, 子对象的实例化, 基类成员的隐藏(派生类成员覆盖基类成员)

    [源码下载] 不可或缺 Windows Native (21) - C++: 继承, 组合, 派生类的构造函数和析构函数, 基类与派生类的转换, 子对象的实例化, 基类成员的隐藏(派生类成员覆盖基类成 ...

  6. 从零开始学C++之继承(二):继承与构造函数、派生类到基类的转换

    一.不能自动继承的成员函数 构造函数 析构函数 =运算符 二.继承与构造函数 基类的构造函数不被继承,派生类中需要声明自己的构造函数. 声明构造函数时,只需要对本类中新增成员进行初始化,对继承来的基类 ...

  7. C++ 继承 - 在派生类中对基类初始化

    构造函数与基类的其他成员不同,不能被派生类继承,因此为了初始化基类中的成员变量,需要在派生类中调用基类的构造函数(即显式调用),如果派送类没有调用则默认调用基类的无参构造函数(即隐式调用). 显式调用 ...

  8. 【转载】C++中的基类与派生类

    转自:http://www.cnblogs.com/sujz/articles/2044365.html 派生类的继承方式总结: 继承方式 说明 public 基类的public和protected的 ...

  9. C++中的基类与派生类

    派生类的继承方式总结: 继承方式 说明 public 基类的public和protected的成员被派生类继承后,保持原来的状态 private 基类的public和protected的成员被派生类继 ...

随机推荐

  1. 前端模块化IIFE,commonjs,AMD,UMD,ES6 Module规范超详细讲解

    目录 为什么前端需要模块化 什么是模块 是什么IIFE 举个栗子 模块化标准 Commonjs 特征 IIFE中的例子用commonjs实现 AMD和RequireJS 如何定义一个模块 如何在入口文 ...

  2. css面试题汇总 (持续更新)

    前言:这篇随笔是为了准备后面的面试而整理的,网上各种面试题太多了,但是我感觉很多太偏了,而且实际开发过程中并不会遇到,因此这里我整理一些比较常用的,或者是相对比较重要的知识点,每个知识点都会由浅入深, ...

  3. Python数据清洗:提取爬虫文本中的电话号码

    步骤索引 效果展示 注意事项 代码 很多人学习python,不知道从何学起.很多人学习python,掌握了基本语法过后,不知道在哪里寻找案例上手.很多已经做案例的人,却不知道如何去学习更加高深的知识. ...

  4. Codehorses T-shirts (map+遍历)

    Codehorses has just hosted the second Codehorses Cup. This year, the same as the previous one, organ ...

  5. Codeforces 1324F Maximum White Subtree DFS

    题意 给你无根一颗树,每个节点是黑色或白色.对于每一个节点,问包含该节点的权值最大的子树. 子树的权值等于子树中白点的个数减去黑点的个数. 注意,这里的子树指的是树的联通子图. 解题思路 这场就这题卡 ...

  6. Content Security Policy (CSP)内容安全策略总结

    跨域脚本攻击 XSS 是最常见.危害最大的网页安全漏洞. 为了防止它们,要采取很多编程措施,非常麻烦.很多人提出,能不能根本上解决问题,浏览器自动禁止外部注入恶意脚本?这就是"网页安全政策& ...

  7. Activiti7 生成表结构

    首先创建一个Maven项目 整体的项目结构 activiti.cfg.xml配置文件 <?xml version="1.0" encoding="UTF-8&quo ...

  8. Zabbix icmp pinger processes more than 75% busy

    Zabbix icmp pinger processes more than 75% busy   Zabbix server报"Zabbix icmp pinger processes m ...

  9. fake_useragent.errors.FakeUserAgentError: Maximum amount of retries reached解决方法!

    UserAgent 就是用户代理,又叫报头,是一串字符串,相当于浏览器的身份证号,在利用爬虫爬取网站数据时,频繁更换它可以避免触发相应的反爬机制. fake-useragent对频繁更换UserAge ...

  10. virtualbox虚拟机之连接本地主机同时可以连接外部网络

    如果主机需要通过ssh,ftp等方式访问linux虚拟机,是无法实现的.这个时候要实现端口互通,我们要用到VirtualBox的端口转发功能.所谓的端口转发功能,就是借助主机上虚拟出来的Virtual ...