继承的权限问题

      首先什么是继承呢？

继承的概念；继承机制是面向对象程序设计使代码可以复用的最重要的手段，他允许程序员在保持原有的类特性的基础上进行扩充，增加功能。这样产生了新的类，成为派生类，继承呈现了面对对象程序设计的层次结构，体现了由简单到复杂的认知过程。   

       这样来看我们就知道了继承的作用

1）实现代码复用

2）实现多态性

       继承的格式是什么呢

 

了解了这些，下来我们就要正式开始讨论继承的权限问题了

 

首先讨论公有，还是像以前一样看程序的运行情况，来推出结论。这里需要有一个父类，有一个子类，还要有一个孙子类来推断元素由 父类继承到子类会的权限，如下；

首先我们用如下这段代码来讨论公有继承，

#include <iostream>
using    namespace   std;

class Base
{
        public:
                void SetValue (int pri,int pro,int pub)
                {
                        _pri=pri;
                        _pro=pro;
                        _pub=pub;
                }
        private:
                int _pri;
        protected:
                int _pro;
        public:
                int _pub;
};
class Derived:public   Base
{
        public:
                void SetValueD (int pri,int pro,int pub)
                {

                }
        private:
                int _priD;
        protected:
                int _proD;
        public:
                int _pubD;

};

int main ()
{
        cout <<sizeof (Derived)<<endl;
        Derived   d;
        d.SetValue(10,20,30);
        return 0;
}

根据运行结果可以看出新类型的大小为24个字节（6个整型变量），又用子类调用了SetValue（）函数，也就是说子类继承了父类的全部成员（变量与函数）。，又因为SetValue（）在类外被成功调用，所以说明SetValue（）这个在基类型中的公有成员函数在被公有继承之后，在子类中还是公有的成员函数

我们来对代码做一点小小的改动(红字部分是新加的)

#include <iostream>
using    namespace   std;

class Base
{
        public:
                void SetValue (int pri,int pro,int pub)
                {
                        _pri=pri;
                        _pro=pro;
                        _pub=pub;
                }
        private:
                int _pri;
        protected:
                int _pro;
        public:
                int _pub;
};
class Derived:public   Base
{
        public:
                void SetValueD (int pri,int pro,int pub)
                {
                     _pro=10;
                }
        private:
                int _priD;
        protected:
                int _proD;
        public:
                int _pubD;

};

int main ()
{
        cout <<sizeof (Derived)<<endl;
        Derived   d;
        d.SetValue(10,20,30);
        return 0;
}  _pro=10;
                }
        private:
                int _priD;
        protected:
                int _proD;
        public:
                int _pubD;

};

int main ()
{
        cout <<sizeof (Derived)<<endl;
        Derived   d;
        d.SetValue(10,20,30);
        return 0;
}

 

 

如图，编译器并没有为我们报错，也就是说基类的保护成员在子类是可以被访问的。

#include <iostream>
using    namespace   std;

class Base
{
        public:
                void SetValue (int pri,int pro,int pub)
                {
                        _pri=pri;
                        _pro=pro;
                        _pub=pub;
                }
        private:
                int _pri;
        protected:
                int _pro;
        public:
                int _pub;
};
class Derived:public   Base
{
        public:
                void SetValueD (int pri,int pro,int pub)
                {

                }
        private:
                int _priD;
        protected:
                int _proD;
        public:
                int _pubD;

};

int main ()
{
        cout <<sizeof (Derived)<<endl;
        Derived   d;
        d.SetValue(10,20,30)；

        d._pro=20;  d._pro=20;

        return 0;

}

此时程序报错；报错为无法访问基类里的保护成员，也就是说基类的保护成员不可以在类外访问

 

因为一个类中的私有和保护成员都不可以在类外访问，所以不可以确定是继承到子类里是私有的还是保护的权限。还需要下一步的验证，下一步就要探究它到底是保护的还是私有的了，我们在讲程序进行修改；

#include <iostream>
using    namespace   std;

class Base
{
        public:
                void SetValue (int pri,int pro,int pub)
                {
                        _pri=pri;
                        _pro=pro;
                        _pub=pub;
                }
        private:
                int _pri;
        protected:
                int _pro;
        public:
                int _pub;
};
class Derived:public   Base
{
        public:
                void SetValueD (int pri,int pro,int pub)
                {
                 _pri=20;
                }
        private:
                int _priD;
        protected:
                int _proD;
        public:
                int _pubD;

};

int main ()
{
        cout <<sizeof (Derived)<<endl;
        Derived   d;
        d.SetValue(10,20,30);
        return 0;    _pri=20;
                }
        private:
                int _priD;
        protected:
                int _proD;
        public:
                int _pubD;

};

int main ()
{
        cout <<sizeof (Derived)<<endl;
        Derived   d;
        d.SetValue(10,20,30);
        return 0;

}

我们可以看到基类中的私有成员我们在子类中是访问不了的，我们知道了私有成员变量的这种特性之后我们就可以利用它，分辨继承下来的到底是保护类还是私有类了。这时我们需要再建一个子类的子类，也有人叫孙子类，要验证被子类继承之后，到底是私有的还是继承的权限。

假设保护成员在被公有继承之后在子类中的权限是保护的，那么在孙子类中是可以访问的下面我们通过代码来验证一下

#include <iostream>
using    namespace   std;

class Base
{
        public:
                void SetValue (int pri,int pro,int pub)
                {
                        _pri=pri;
                        _pro=pro;
                        _pub=pub;
                }
        private:
                int _pri;
        protected:
                int _pro;
        public:
                int _pub;
};
class Derived:public   Base
{
        public:
                void SetValueD (int pri,int pro,int pub)
                {

                }
        private:
                int _priD;
        protected:
                int _proD;
        public:
                int _pubD;

};
class D:public  Derived
{
        public:
                void FunTest ()
                {
                    _pro=10;
                    _proD=20;

                }

};
int main ()
{
        cout <<sizeof (Derived)<<endl;
        Derived   d;
        d.SetValue(10,20,30);
        return 0;
}
Ty

运行结果没有报错，说明从基类里继承下来到子类之后保护成员还是保护成员。

 

总结一下；基类private成员在派生类中是不能被访问的，如果基类成员不想在 类外直接被访问，但需要在派生类中能访问，就定义为protected。 可以看出保护成员限定符是因继承才出现的

这就是公有继承关于子类继承下来得各权限元素继承后的权限验证过程，其他的继承方式也是一样，就不一一列举了。

下面是总结的一张表，有兴趣的同学可以看看