子类公有继承不能访问父类受保护属性？ cannot access protected member

Posted 2023-05-02

class Base

protected:
int num;
public :

Base(int n=1):num(n)
Base(Base &b)num=b.num;
virtual void fn()

cout<<"this is Base,num="<<num<<"\n";

;
class Sub:public Base

//protected:
// int num;
public :
Sub(int n=10)num=n;
Sub(Base &b)num=b.num;
virtual void fn()

cout<<"this is Sub,num="<<num<<"\n";

;

在 Sub(Base &b)num=b.num; 这行报错
error C2248: 'Base::num' : cannot access protected member declared in class 'Base'
不是说子类可以访问父类除了private以外的属性和方法吗？如果把Base类里面的 num声明为public，就不会报错了。环境是vs2010.
请指教

参考技术A 想访问父类的protected类型数据，需要通过方法调用，不能直接通过对象调用。就算不是继承，普通类的protected成员也不能直接通过类对象来调用，只能通过类方法调用追问

也就是说，protected跟private的区别在于继承之后，protected的在子类还可以利用子类访问，但是private的在子类只占空间但是不能访问？

追答

子类public继承父类，子类对基类的private成员不能访问，protected成员成为派生类的protected成员，public成员成为派生类的public成员
子类protected继承父类，子类对基类的private成员不能访问，protected成员成为派生类的protected成员，public成员成为派生类的protected成员
子类private继承父类，对基类的private成员不能访问，protected成员成为派生类的private成员
public成员成为派生类的private成员
总之，不论什么继承方式，基类的private成员对子类是不可见的，也不能访问，protected成员和public成员会根绝不同的继承方式成为子类的不同类型成员，并且可以访问。

参考技术B class Sub:public Base
因为你的继承方式为public
如果你改成provate那就可以了。
继承方式限定了访问的权限。追问

跟继承方式无关，还是报一样的错，把Base的num声明为public还是可以。我觉得会不会是编译器的问题。
http://blog.csdn.net/luoruiyi2008/article/details/7179788 你看下这里面的。
要不就是父类受保护的不是子类可以访问的。

追答

一般像你这种不想暴露成员的，就要设置public的get和set方法，来对私有的成员进行访问。这是很多书上都推荐的方式。

追问

没有体现protected的意义……那就跟privated一样了

追答

具有protected访问控制级别的成员是半公开的，外界无法直接访问这个控制级别的成员，但是派生类的base指针（在c++中也可用引用访问）可以获得访问能力。protected与private基本相似，只有在继承时有较大的区别。继承的类可以访问protected成员。
不是没有意义，而是作用不一样。

本回答被提问者采纳 参考技术C 继承类只能访问他所继承的那个基类对象的protected，就像你第一个构造函数一样

但是其他所有的基类对象protected都是不可见的，除非定义了友元追问

解决方法就是基类定义一个获取num的函数，然后在子类构造的时候调用吗？
继承类只能访问他所继承的那个基类对象的protected 这个能举个例子吗？

参考技术D 不能直接对父类的数据成员进行操作，一般通过调用父类的成员函数来对父类的数据进行操作 第5个回答  2013-07-16 不要直接调用父类的私有变量，在父类中写成get函数获取吧。安全。

C++继承：公有，私有，保护

公有继承(public)、私有继承(private)、保护继承(protected)是常用的三种继承方式。

1. 公有继承(public)

公有继承的特点是基类的公有成员和保护成员作为派生类的成员时，它们都保持原有的状态，而基类的私有成员仍然是私有的，不能被这个派生类的子类所访问。

2. 私有继承(private)

私有继承的特点是基类的公有成员和保护成员都作为派生类的私有成员，并且不能被这个派生类的子类所访问。

3. 保护继承(protected)

保护继承的特点是基类的所有公有成员和保护成员都成为派生类的保护成员，并且只能被它的派生类成员函数或友元访问，基类的私有成员仍然是私有的。

下面列出三种不同的继承方式的基类特性和派生类特性。

public
protected
private

共有继承
public
protected
不可见

私有继承
private
private
不可见

保护继承
protected
protected
不可见

在上图中：1）基类成员对派生类都是：共有和保护的成员是可见的，私有的的成员是不可见的。

2）基类成员对派生类的对象来说：要看基类的成员在派生类中变成了什么类型的成员。如：私有继承时，基类的共有成员和私有成员都变成了派生类中的私有成员，因此对于派生类中的对象来说基类的共有成员和私有成员就是不可见的。

为了进一步理解三种不同的继承方式在其成员的可见性方面的区别，下面从三种不同角度进行讨论。

对于公有继承方式

(1) 基类成员对其对象的可见性：

公有成员可见，其他不可见。这里保护成员同于私有成员。

(2) 基类成员对派生类的可见性：

公有成员和保护成员可见，而私有成员不可见。这里保护成员同于公有成员。

(3) 基类成员对派生类对象的可见性：

公有成员可见，其他成员不可见。

所以，在公有继承时，派生类的对象可以访问基类中的公有成员；派生类的成员函数可以访问基类中的公有成员和保护成员。这里，一定要区分清楚派生类的对象和派生类中的成员函数对基类的访问是不同的。

对于私有继承方式

(1) 基类成员对其对象的可见性：

公有成员可见，其他成员不可见。

(2) 基类成员对派生类的可见性：

公有成员和保护成员是可见的，而私有成员是不可见的。

(3) 基类成员对派生类对象的可见性：

所有成员都是不可见的。

所以，在私有继承时，基类的成员只能由直接派生类访问，而无法再往下继承。

对于保护继承方式

这种继承方式与私有继承方式的情况相同。两者的区别仅在于对派生类的成员而言，对基类成员有不同的可见性。

上述所说的可见性也就是可访问性。

关于可访问性还有另的一种说法。这种规则中，称派生类的对象对基类访问为水平访问，称派生类的派生类对基类的访问为垂直访问。

看看这样的例子：

#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;

}