【C++中public protected private在子类中成员属性的变化】

C++中public protected private继承后属性的变化

![在这里插入图片描述](https://img-blog.csdnimg.cn/c8ba203bad404ab7a56ba22fb378e258.png

演示中用到的基类

class  ABase
{ 
public: 
	 void printPub()；
protected:
	void printPro();
private:
	void printPri();
}

1.公有继承 public

class BSubPub:public ABase
{ 
};

此时，BSubPub几乎等价于ABase 类的成员及属性一致 public 不改变原来类成员属性

2.保护继承 protected

class BSubPro :protected ABase
{  
};

ASubPro中，原来的public变为了protect，protect仍旧是protect private 仍旧是private，相当于下面的类

class BSubPro  
{ 
protected: //public: 在protected继承中 变为了protected
	 void printPub()；
protected:
	void printPro();
private:
	void printPri();
};

3.私有继承 private

class BSubPri :private ABase
{  
};

ASubPri中，原来的public变为了private，protect变为了private private 仍旧是private，相当于下面的类

class BSubPri 
{ 
private: //public: 在protected继承中 变为了protected
	 void printPub()；
private: //protected:在protected继承中 变为了protected
	void printPro();
private:
	void printPri();
};

4.综上所述

以下是对这三种继承的一个总结

class  ABase           public       protected    private   
{ 
public:                public:      protected:   private:           
	 void printPub()；
protected:             protected:   protected:   private:                  
	void printPro();
private:               private:     private:     private:                      
	void printPri();
}

5.using在继承中的应用

如果出现 即是私有继承 但又需要使对象访问基类的公有成员

class BSubPri :private ABase
{  
};

BSubPri  b;
b.printPub()； //因为是私有继承 子类对象无访问权限 

那该如何解决此问题呢 这时候使用using，问题迎刃而解 ，用法如下：

class BSubPri :private ABase
{  
public : 
	using ABase::printPub;
};

BSubPri  b;
b.printPub()； //可以正常调用 问题解决 

6.测试代码

以下提供了对三种继承的应用演示机using在继承中的简单应用

 class  ABase
{ 
public: 
	void printPub()
	{
		printf("public fun\n");
	}

	void callABaseFunProPri()
	{
		printf("callABaseFunProPri ：start----------------\n");
		printPro();
		printPri(); 
		printf("callABaseFunProPri ：end----------------\n\n");
	}

protected:
	void printPro()
	{
		printf("protected ABase_fun\n");
	}

private:
	void printPri()
	{
		printf("private ABase_fun\n");
	}

};
  
class BSubPub:public ABase
{
public: 
	void callBSubPubFun()
	{
		printf("callBSubPubFunProPri ：start+++++++++++++++\n");
		printPro();      //保护 正常调用 
		//printPri();    //基类私有 无法调用
		printf("callBSubPubFunProPri ：end++++++++++++++++++\n\n");
	}
};

class BSubPro :protected ABase
{
public:
	void callBSubProFun()
	{
		printf("callBSubProFun ：start+++++++++++++++\n");
		printPro();      //保护 正常调用 
		//printPri();    //基类私有 无法调用
		printf("callBSubProFun ：end++++++++++++++++++\n\n");
	}
};

class BSubPri :private ABase
{
public:
	void callBSubPriFun()
	{
		printf("callBSubPriFun ：start+++++++++++++++\n");
		printPro();      //基类保护变为私有 正常调用 
		//printPri();	 //基类私有 无法调用
		printf("callBSubPriFun ：end++++++++++++++++++\n\n");
	}
};

// 对保护继承的公有及保护类型的验证
class CSubPub :protected BSubPro
{
public:
	void callCSubPubProFun()
	{
		printf("callCSubPubFun ：start+++++++++++++++\n");
		printPro();      //保护 正常调用 
		//printPri();	 //printPri();    //基类私有 无法调用
		printf("callCSubPubFun ：end++++++++++++++++++\n\n");
	}
};

class CSubPubEx :protected BSubPro
{
public:
	using ABase::printPub;
public:
	void callCSubPubProFun()
	{
		printf("callCSubPubExProFun ：start+++++++++++++++\n");
		printPro();      //保护 正常调用 

						 //printPri();	 //printPri();    //基类私有 无法调用
		printf("callCSubPubExProFun ：end++++++++++++++++++\n\n");
	}
};
 
int main()
{
	ABase ab;
	ab.printPub(); 
	ab.callABaseFunProPri();

	//公有继承
	BSubPub bs1;
	bs1.printPub();       //公有继承 仍未公有类型
	bs1.callBSubPubFun();

	//保护继承
	BSubPro bs2;
	//bs2.printPub();     //保护继承 基类公有变为保护 不可在外部调用
	bs2.callBSubProFun();

	//私有继承
	BSubPri bs3;
	bs3.callBSubPriFun();  

	//保护继承
	CSubPub cs;
	cs.callCSubPubProFun();
	//cs.printPub();       //保护继承 公有变为保护

	//私有继承 using用法
	CSubPubEx csEx;
	csEx.callCSubPubProFun();
	csEx.printPub();       // 使用using ABase::printPub; 还原为public

	cout << endl;
	system("pause");
    return 0;
}