派生类访问控制

小灰灰 2023-07-09 02:25 1阅读 0赞

当用public修饰时，所有地方都可以访问

当用protected修饰方法或者属性时，只能在本类或者子类中被访问，protected的一个很明显作用是想将一些东西传递给子类

当用private修饰方法或者属性时，只能在本类中被访问

关于继承的时候，

当采用public继承时，如class B: public A, 那么A类的所有访问权限原封不动的传给子类B，A类中的private的内容在子类B中是不能访问的。

当采用protected继承时，如class B: protected A，那么A类的public领域内的内容会变成子类B中protected领域的内容，A类protected领域的内容也会变成子类B中protected中的内容，A类中private的内容在子类B中时不能访问的。

当采用private继承时，如class B: private A, 那么A类中的public, protected内容会变成类B中的private内容，类A中原有的private内容在子类B中是不能访问的。

即：

**1****）C++****中的继承方式会影响子类的对外访问属性**

public继承：父类成员在子类中保持原有访问级别

private继承：父类成员在子类中变为private成员

protected继承：父类中public成员会变成protected

父类中protected成员仍然为protected

父类中private成员仍然为private

2）**private****成员在子类中依然存在，但是却无法访问到。不论种方式继承基类，派生类都不能直接使用基类的私有成员** **。**

具体看如下代码：

#include <iostream>
    using namespace std;
    
    //public 修饰的成员变量 方法 在类的内部 类的外部都能使用
    //protected: 修饰的成员变量方法,在类的内部使用 ,在继承的子类中可用 ;其他 类的外部不能被使用
    //private: 修饰的成员变量方法 只能在类的内部使用 不能在类的外部
    
    //派生类访问控制的结论
    //1 protected 关键字 修饰的成员变量 和成员函数 ,是为了在家族中使用 ,是为了继承
    //2 项目开发中 一般情况下 是 public
    //3
    
    
    class Parent
    {
    public:
    			int a; //老爹的名字
    protected:
    			int b; //老爹的银行密码
    private:
    			int c; //老的情人
    };
    
    
    //保护继承
    class Child3 : protected Parent
    {
    public:
    protected:
    private:
    public:	
    	void useVar()
    	{
    		a = 0; // ok
    		b = 0; // ok //b这这里 写在了子类Child3的内部  2看protected 3密码===>protected
    		//c = 0; //err
    	}
    };
    
    void main()
    {
    	Child3 c3;
    	//c3.a = 10; //err
    	//c3.b = 20; //err
    	//c3.c = 30;//err
    
    }
    
    
    
    //私有继承
    class Child2 : private Parent
    {
    public:
    	void useVar()
    	{
    		a = 0; //ok
    		b = 0; //ok
    		//c = 0; // err
    	}
    
    protected:
    private:
    };
    
    void main22()
    {
    	Child2 c2;
    	//c1.a = 10; err
    	//c2.b = 20; err
    	//c3.b = 30;
    }
    
    
    
    class Child : public Parent
    {
    public:
    	void useVar()
    	{
    		a = 0; //ok
    		b = 0; //ok
    		//c = 0; // err
    	}
    
    protected:
    private:
    };
    
    
    /*
    C++中的继承方式（public、private、protected）会影响子类的对外访问属性	
    	判断某一句话，能否被访问
    	1）看调用语句，这句话写在子类的内部、外部
    	2）看子类如何从父类继承（public、private、protected）	
    	3）看父类中的访问级别（public、private、protected）
    */
    //共有继承 
    void main21()
    {
    	Parent t1, t2;
    	t1.a  = 10; //ok
    	//t1.b = 20; //err
    	//t2.c = 30 ; //err
    	
    	cout<<"hello..."<<endl;
    	system("pause");
    	return ;
    }

再看另外一个代码：

//类的继承方式对子类对外访问属性影响
    
    #include <cstdlib>
    #include <iostream>
    
    using namespace std;
    
    class A
    {
    private:
    	int a;
    protected:
    	int b;
    public:
    	int c;
    
    	A()
    	{
    		a = 0;		b = 0;		c = 0;
    	}
    
    	void set(int a, int b, int c)
    	{
    		this->a = a;		this->b = b;		this->c = c;
    	}
    };
    class B : public A
    {
    public:
    	void print()
    	{
    		//cout<<"a = "<<a; //err
    		cout<<"b = "<<b; //ok
    		cout<<"c = "<<endl; //ok
    	}
    };
    
    class C : protected A
    {
    public:
    	void print()
    	{
    		//cout<<"a = "<<a; //err
    		cout<<"b = "<<b; // ok
    		cout<<"c = "<<endl; //ok
    	}
    };
    
    class D : private A
    {
    public:
    	void print()
    	{
    		//cout<<"a = "<<a; //err
    		cout<<"b = "<<b<<endl;  //ok
    		cout<<"c = "<<c<<endl; // ok
    	}
    };
    
    int main()
    {
    	
    	A aa;
    	B bb;
    	C cc;
    	D dd;
    
    	aa.c = 100;  //ok
    	bb.c = 100; // ok
    	//cc.c = 100; // err 保护的
    	//dd.c = 100;  // err
    	
    	aa.set(1, 2, 3); //ok
    	bb.set(10, 20, 30); //ok
    	//cc.set(40, 50, 60); // err
    	//dd.set(70, 80, 90);  //err
    	
    
    	bb.print(); //ok
    	cc.print(); //ok
    	dd.print(); //
    
    
    	/**/
    	system("pause");
    	return 0;
    }