精华内容
下载资源
问答
  • public公有继承 protected保护继承 private私有继承  我们知道类的private和protected成员,在类外是不可以使用的.只有public成员可以在类外直接使用.  公有继承时,基类的private成员派生类也不可用,基类的public...
    public公有继承 protected保护继承 private私有继承 
    我们知道类的private和protected成员,在类外是不可以使用的.只有public成员可以在类外直接使用. 
    公有继承时,基类的private成员派生类也不可用,基类的public和protected成员在派生类中可直接使用.继承过来(变成派生类相应的public和protected成员)只有public成员在派生类外可以直接使用.
     保护继承时,基类的private成员仍为有私有.基类的public和protected成员变成派生类的protected成员,这时在派生类外也不能直接使用原基类的public成员 
    私有继承时,基类的private成员仍为有私有.基类的public和protected成员将变成派生类的private成员.
    展开全文
  • protected保护继承 private私有继承 我们知道类的private和protected成员,在类外是不可以使用的.只有public成员可以在类外直接使用. 公有继承时,基类的private成员派生类也不可用,基类的public和protected...
    public公有继承
    
    protected保护继承
    private私有继承

    我们知道类的private和protected成员,在类外是不可以使用的.只有public成员可以在类外直接使用.

    公有继承时,基类的private成员派生类也不可用,基类的public和protected成员在派生类中可直接使用.继承过来(变成派生类相应的public和protected成员)只有public成员在派生类外可以直接使用.

    保护继承时,基类的private成员仍为有私有.基类的public和protected成员变成派生类的protected成员,这时在派生类外也不能直接使用原基类的public成员

    私有继承时,基类的private成员仍为有私有.基类的public和protected成员将变成派生类的private成员.

    举个例子.

    class A
    {
    public:
    int m_nTelNum;
    protected:
    int m_nAge;
    private:
    int m_nMoney;
    };
    class B:public A
    {
    void SetTelNum(int nTelNum)
    {
    m_nTelNum=nTelNum;
    }
    void SetAge(int nAge)
    {
    m_nAge=nAge;
    }
    void SetMoney(int nMoney)
    {
    m_nMoney=nMoney;//这里就出现错误,因为基类的private成员不能用.
    }
    };

    B objB;//创建B类的对象objB
    objB.m_nTelNum=123456;//可以
    objB.m_nAge=30;//错误.public继承中基类的protected在派生类中是protected
    objB.m_nMoney=100;//更错误,在派生类中都不可以直接使用.在类外就更不能了.

    class C:protected A
    {
    void SetTelNum(int nTelNum)
    {
    m_nTelNum=nTelNum;
    }
    void SetAge(int nAge)
    {
    m_nAge=nAge;
    }
    void SetMoney(int nMoney)
    {
    m_nMoney=nMoney;//这里就出现错误,因为这是基类的private成员不能用.
    }
    };

    C objC;//创建C类的对象objC
    objC.m_nTelNum=123456;//注意这里和public的区别,这里错误,m_nTelNum变成了C类的protected成员
    objC.m_nAge=30;//错误.protected继承中基类的protected在派生类中是protected,这与public同相
    objC.m_nMoney=100;//更错误,在派生类中都不可以直接使用.在类外就更不能了.

    class D:private A
    {
    void SetTelNum(int nTelNum)
    {
    m_nTelNum=nTelNum;
    }
    void SetAge(int nAge)
    {
    m_nAge=nAge;
    }
    void SetMoney(int nMoney)
    {
    m_nMoney=nMoney;//这里就出现错误,因为这是基类的private成员不能用.
    }
    };

    D objD;//创建D类的对象objD
    objD.m_nTelNum=123456;//错误,m_nTelNum变成了D类的private成员
    objD.m_nAge=30;//错误.private继承中基类的protected在派生类中是private
    objD.m_nMoney=100;//更错误,在派生类中都不可以直接使用.在类外就更不能了.

    从例子来看,三种继承从派生类内部引用来看好像没有区别,只在类外引用时表现不同.现在还看不出public和protected继承的区别
    那再看一个例子.
    class E:public B
    {
    void SetTelNum(int nTelNum)
    {
    m_nTelNum=nTelNum;//可以 因为这是B的公有成员
    }
    void SetAge(int nAge)
    {
    m_nAge=nAge;//可以 因为这是B的保护成员,现成变成E的protected成员
    }
    void SetMoney(int nMoney)
    {
    m_nMoney=nMoney;//这个肯定不可以!
    }
    };
    E objE;//
    objE.m_nTelNum=123456;//可以
    //其它的两个就不能用了.
    class F:public C
    { 
    void SetTelNum(int nTelNum)
    {
    m_nTelNum=nTelNum;//可以 因为这是C的保护成员,这里与public继承已经有区别但还没有表现出来
    }
    void SetAge(int nAge)
    {
    m_nAge=nAge;//可以 因为这是C的保护成员,现成变成E的protected成员
    }
    void SetMoney(int nMoney)
    {
    m_nMoney=nMoney;//这个肯定不可以!
    }
    };
    F objF;
    objF.m_nTel=123456;//错误,因为这是F的保护成员.注意与E类区别
    class G:public D
    {
    void SetTelNum(int nTelNum)
    {
    m_nTelNum=nTelNum;//不可以 因为这是D的private成员,注意这里区别
    }
    void SetAge(int nAge)
    {
    m_nAge=nAge;//不可以 因为这是D的private成员,注意区别
    }
    void SetMoney(int nMoney)
    {
    m_nMoney=nMoney;//这个肯定不可以!
    }
    };
    //那G在类外就没有了可以引用的继承过来成员了!
    //这些继承方式是很难理解的.最好的办法就是多写代码去试.
    展开全文
  • C++中的继承 public protected private

    千次阅读 2014-03-28 11:03:50
    public protected private共有继承 public protected 不可见私有继承 private private 不可见保护继承 protected protected 不可见 #include using namespace std; ////////
     
    
                 public      protected       private
    共有继承 public protected 不可见
    私有继承 private private 不可见
    保护继承 protected protected 不可见
     
    
    #include<iostream>
    using namespace std;
    //
    class A       //父类
    {
    private:
        int privatedateA;
    protected:
        int protecteddateA;
    public:
        int publicdateA;
    };
    //
    class B :public A      //基类A的派生类B(共有继承)
    {
    public:
        void funct()
        {
            int b;
            b=privatedateA;   //error:基类中私有成员在派生类中是不可见的
            b=protecteddateA; //ok:基类的保护成员在派生类中为保护成员
            b=publicdateA;    //ok:基类的公共成员在派生类中为公共成员
        }
    };
    //
    class C :private A  //基类A的派生类C(私有继承)
    {
    public:
        void funct()
        {
            int c;
            c=privatedateA;    //error:基类中私有成员在派生类中是不可见的
            c=protecteddateA;  //ok:基类的保护成员在派生类中为私有成员
            c=publicdateA;     //ok:基类的公共成员在派生类中为私有成员
        }
    };
    //
    class D :protected A   //基类A的派生类D(保护继承)
    {
    public:
        void funct()
        {
            int d;
            d=privatedateA;   //error:基类中私有成员在派生类中是不可见的
            d=protecteddateA; //ok:基类的保护成员在派生类中为保护成员
            d=publicdateA;    //ok:基类的公共成员在派生类中为保护成员
        }
    };
    //
    int main()
    {
        int a;
     
        B objB;
        a=objB.privatedateA;   //error:基类中私有成员在派生类中是不可见的,对对象不可见
        a=objB.protecteddateA; //error:基类的保护成员在派生类中为保护成员,对对象不可见
        a=objB.publicdateA;    //ok:基类的公共成员在派生类中为公共成员,对对象可见
     
        C objC;
        a=objC.privatedateA;   //error:基类中私有成员在派生类中是不可见的,对对象不可见
        a=objC.protecteddateA; //error:基类的保护成员在派生类中为私有成员,对对象不可见
        a=objC.publicdateA;    //error:基类的公共成员在派生类中为私有成员,对对象不可见
     
        D objD;
        a=objD.privatedateA;   //error:基类中私有成员在派生类中是不可见的,对对象不可见
        a=objD.protecteddateA; //error:基类的保护成员在派生类中为保护成员,对对象不可见
        a=objD.publicdateA;    //error:基类的公共成员在派生类中为保护成员,对对象不可见
     
        return 0;
    }

    如果是private继承,可以使用public,使得基类中的一些成员对外可见,如果这些成员在基类中是protected或者public。

    // test.cpp : 定义控制台应用程序的入口点。
    //
    
    #include "stdafx.h"
    #include <cstdlib>
    #include <new>
    #include <iostream>
    using namespace std;
    
    class Base{
    public:
    	int f(){
    		cout<<"int f() Base"<<endl;
    		return 0;
    	}
    
    	int g(){
    		cout<<"int g() Base"<<endl;
    		return 0;
    	}
    };
    
    class Derived1:private Base{
    public:
    	int h()
    	{
    		cout<<"int h() Derived1"<<endl;
    		return Base::f();
    	}
    public:
    	Base::g;
    };
    
    
    int _tmain(int argc, _TCHAR* argv[])
    {
    	Derived1 d1;
    	Base b;
    	d1.h();
    	d1.g();
    
    	return 0;
    }
    


    展开全文
  • c++继承protected

    2017-09-07 20:17:43
    c++继承protected

    继承是面向对象重要的特性,也较为复杂。继承主要的问题是:派生类对基类成员的访问权限。

    private和public相信“众所周知”,public成员可以被类的对象、派生类成员访问,而private仅允许本类的成员函数访问。

    本文主要解释protected:protected成员和protected继承。

    protected成员:希望与派生类共享但拒绝外界直接访问的成员。

    protected成员可以看作是public和private的中和体:

    1. 具有private成员的一部分性质:不允许直接通过类的对象访问。

    2. 具有public成员的一部分性质:派生类可以直接访问基类的protected成员。

    当然当这两条性质是protected的最基本性质,但还存在另一条很重要的性质:

    3. 派生类成员或友元不能访问基类对象的受保护成员,但可以访问派生类对象的受保护成员(当然公有成员也可以访问),且与继承方式无关。

    注意这里强调用对象访问!

    举个栗子:

    class Base  
    {  
    protected:
            int i;  
    private:
            int j;  
    };
    class derive:public Base  
    {  
    public:  
        int f(derive& s)  
        {  
            s.i = 0;    //正确 可以在派生类中通过派生类对象访问基类的受保护成员 但基类私有成员不可访问  
            return i;  
        }  
        int f(Base& s)  
        {  
            s.i = 0;    //错误 不能在派生类中访问基类对象的受保护成员  
            return i;  
        }  
    };

    继承:

    继承的过程:

    1. 全盘接受基类的所有成员,但构造函数和析构函数除外。

    2. 根据继承方式改变基类成员在派生类中的访问控制权限。

    3. 同名覆盖。

    4. 添加派生类独有的新成员。

    要强调的是:所有继承方式(public,protected,private)不会影响派生类的访问权限,只会改变基类成员在派生类的访问属性。

    也就是说,即使是private继承,派生类依然可以访问基类的public和protected成员,只不过原来基类的成员在派生类中变成了private属性。

    仍然是刚才的例子:

    class Base
    {
    public:
            int i;
    protected:
            int j;
    private:
            int k;
    };
    class derive:private Base
    {
            //......
    };
    derive类使用了私有继承,但该类的成员函数依然可以访问Base类中的成员i和j,同时依然不能访问Base类中的成员k。

    private继承和protected继承的区别:

    在多重继承中能看出两者的区别,以两次继承为例:

    第一次继承如果使用private继承,那么基类的所有成员在子类中均为private,第二次继承时无论何种继承方式,孙类成员函数都不能访问任何子类继承自基类的成员。

    但如果第一次继承如果使用protected继承,基类public、protected成员在子类为protected,第二次继承时无论何种继承方式,孙类成员函数能访问子类继承自基类的public和protected成员。

    举个栗子:

    class Base
    {
    public:
            int i;
    protected:
            int j;
    private:
            int k;
    };
    class derive:protected Base
    {
    public:
            int m;
    };
    class re_derive :private derive    //private继承不影响对基类public和protected成员的访问
    {
    public:
    	void f()
    	{
                    i = 0; j = 0;    //由于第一次继承是protected继承 因此可以访问子类继承自基类的成员i,j
                                     //倘若第一次继承是私有继承 i,j将都不可访问
    	}
    };

    参考文献:

    [1]Lippman,S.B. & Lajoie,J. & Moo,B.E.著; 王刚 & 杨巨峰译.C++ Primer中文版:第五版[M].北京:电子工业出版社,2013.9:542-544

    展开全文
  • C++中常见的3种继承方式:public 继承protected 继承和private继承public 当采用公有继承时,基类成员对其对象的可见性与一般类及其对象的可见性相同,公有成员课件,其他成员不可见。基类成员对派生类的可见性对...
  • 1 三种继承方式    (1) 公有继承(public) 公有继承的特点是基类的公有成员和保护成员作为派生类的成员时,它们都保持原有的状态,而基类的私有成员仍然是私有的,不能被这个派生类的子类所访问。  (2) 私有...
  • 私有继承(private):继承的访问控制:基类的public和protected成员:都以private身份出现在派生类中基类的private成员:不可直接访问访问权限:派生类中的成员函数:可以直接访问基类中的public和protected成员,但...
  • 三种访问权限 public:可以被任意实体访问 protected:只允许子类及本类的成员函数访问 private:只允许本类的成员函数访问 三种继承方式 public 继承 ...protectedprotected继承 => protected protecte
  • 工作的越久,基础淡忘的就越多,重新总结下继承: 第一:private, public, protected 访问标号的访问范围。 private:只能由1.该类中的函数、2.其友元函数访问。 不能被任何其他访问,该类的对象也不...
  • C++ protected friend 继承

    千次阅读 2016-08-22 16:01:58
    protected专门就是为继承(子类)设计的 用public继承 那么基类所有的访问标识在子类不变 protected还是protected protected只有类本身 和类的子类可以访问,对象是无法访问的! 除了在继承上 他跟private没有...
  • java继承protected权限再理解

    千次阅读 2018-04-06 21:28:47
    java会继承父类中default权限以上的成员 父类的private成员不会...父类的 protected 成员继承为子类的protected 成员。就好像他们直接定义在子类中一样。 父类的 public 成员继承为子类的public 成员,就好像他们...
  • Protected:继承访问权限

    2019-09-20 16:11:25
    关键字protected处理的是继承关系。 如果创建了一个新包,并从另一个包中继承一个类,那么唯一可访问的成员就是public类型的成员(当然,如果在同一个包中执行继承工作,就可以操纵所有拥有包访问权限的成员) 有时...
  • 考虑从基类B派生出的类D:   ——如果B是private基类,那么它的public和protected成员只能由D的成员函数和友元访问。  只有D的成员和友元能将D*转换成B*。   ——如果B是...
  • 继承时,protected可等同private;有继承时,在派生类会有不同。二 总结有两点,如下: 1对象与类的关系: 基类对象不能访问基类的protected的成员 但是类与类之间,派生类可以访问基类的protected的成员。 2...
  • 1、public继承  public派生被称为类型继承。派生类型是基类的子类型,它改写了基类中所有与类型相关的成员函数,而继承了共享的成员... 在protected继承下,基类的所有公有成员都成为派生类的protected成员。 个人
  • 第一:private, public, protected 访问标号的访问范围。 private:只能由1.该类中的函数、2.其友元函数访问。 不能被任何其他访问,该类的对象也不能访问。 protected:可以被1.该类中的函数、2.子类的函数、...
  • public private 和protected 继承   在C++中继承主要有三种关系:public、protected和private。这三种继承关系中public继承是最为常用的一种继承关系,private继承是最少见的继承关系。 1. public 从语义...
  • 继承Protected修饰符(C#)

    千次阅读 2016-03-09 21:31:25
    继承: 1.基类中受保护成员只能从基类及其派生类中访问 2.实例化派生类时,会首先调用基类的构造器,避免遗忘对基类的构造器 3.基类如果没有可访问的构造器,编译器就不清楚如何构造基类,进而报错 4.避免出现这个...
  • 公有继承(public)、私有继承(private)、保护继承(protected)是常用的三种继承方式。 1. 公有继承(public) 公有继承的特点是基类的公有成员和保护成员作为派生类的成员时,它们都保持原有的状态,而基类的私有成员...
  • * 问题描述:protected继承方式 * 样例输入: * 样例输出: * 项目要求:【理解基类中成员的访问限定符和派生类的继承方式。】 */ #include using namespace std; class Animal { public: Animal
  • 1, 公有继承(public) 基类成员对其对象的可见性与一般类及其对象的可见性相同,public成员可见,protected和private成员不可见。 基类成员对派生类的可见性对派生类来说,基类的public和protected成员可见...
  • 在C++ 中继承主要有三种关系:public 、protected 和private 。这三种继承关系中public 继承是最为常用的一种继承关系,private 继承是最少见的继承关系。 1. public 从语义角度上来说,public 继承是一种接
  • public protected private

    万次阅读 2019-03-14 21:22:47
    三种访问权限 public:可以被任意实体访问 protected:只允许子类及本类的成员函数访问 private:只允许本类的成员函数访问 三种继承方式 ...public 继承 ...protected 继承 ...public & protected继承 =...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 462,885
精华内容 185,154
关键字:

继承protected