实验二 C++继承

• 一. 实验内容
• • 1. 继承访问权限测试
  • 2. 友元类继承测试
• 二. 实验过程及分析
• • 访问权限
  • • 1.1 访问权限测试代码
    • 1.2 继承访问结果分析
  • 友元继承
  • • 2.1 友元类继承测试代码
    • 2.2 友元测试代码分析

• 设计类A具有public, protected, private等不同属性的成员函数或变量；
• 类B通过public, protected, private等不同方式继承A，在类B的成员函数中测试访问A的成员函数或变量；
• B以private方式继承A，尝试把A中的部分public成员提升为public。

• 设计类A含有私有变量a，在类A中友元给类C；
• 设计类B继承A，添加私有变量b；在类C中测试访问类B的成员变量a, b;
• 设计类D继承C，在D的成员函数中测试访问类A的成员变量a，类B的成员变量a, b。

// 继承访问权限测试

class A {          // A父类
public:
	int _a;
protected:
	int _b;
private:
	int _c;

};

class Pub_B :public A {   //子类 public继承
public:
	void Test() {
		_a = 10;
		_b = 10;
		//_c = 10; 不可访问
		
	}
	int pub_pub_a1 = 11;
protected:
	int pub_pro_b1 = 12;
private:
	int pub_pri_c1 = 13;

};

class Pro_B :protected A {  //子类 protected继承
public:
	void Test() {
		_a = 15;
		_b = 15;
		//_c = 15;不可访问
	}
	int pro_pub_a2 = 16;
protected:
	int pro_pro_b2 = 17;
private:
	int pro_pri_c2 = 18;
};

class Pri_B :private A {    //子类 private继承
public:
	void Test() {
		_a = 20;
		_b = 20;
		//_c = 20;不可访问
	}
	int pri_pub_a3 = 21;
protected:
	int pri_pro_b3 = 22;
private:
	int pri_pri_c3 = 23;
};

class newPri_B :private A {
public:
	void test() {
		_a = 30;
		_b = 30;
		//_c = 30;
	}
	int pri_pub_a;
	using A::_a;
	using A::_b;
	//using A::_c;
protected:
	int pri_pro_b;
private:
	int pri_pri_c;

};

void test() {
	A a;
	a._a;
	//a._b;
	//a._c;

	Pub_B b1;
	b1._a;
	b1.pub_pub_a1;
	//b1._b;
	//b1._c;
	//b1.pub_pro_b1;
	//b1.pub_pri_c1;

	Pub_B b2;
	b2._a;
	//b2._b;
	//b2._c;
	//b2.pro_pbu_a2;
	//b2.pro_pro_b2;
	//b2.pro_pri_c2;

	Pub_B b3;
	b3._a;
	//b3._b;
	//b3._c;
	//b3.pri_pub_a3;
	//b3.pri_pro_b3;
	//b3.pri_pri_c3;

   class newPri_B b4;
	b4._a;
	b4._b;
	//b4._c;
	b4.pri_pub_a;
	//b4.pri_pro_b;
	//b4.pri_pri_c;
}

1. 子类可以访问父类的public和protected而外部只能访问public，当子类以private继承父类，则从main函数里不能访问任何子类和父类变量，但是可以通过使用using修改基类成员的访问权限。
2. 如：子类Pri_B私有继承A，所以A中共有成员在子类Pri_B是私有的，它不能被外部访问。但是使用using重新声明后，main()函数中可以使用,如上诉代码中的newPri_B中的{using A::_a ; using A::_b;}，现在即可在访问_a和_b，因为_c在A中为private的，所以即便使用了using还是不能访问。

代码段1：
class A {          // A父类
public:
	int _a;
protected:
	int _b;
private:
	int _c;
	friend class C;
};

代码段2：
class B :public A {
public:
	int b1;
protected:
	int b2;
private :
	int b3;

};

代码段3：
class C {
public:
	void test() {
		B b;
		b.b1;
		//b.b2;
		//b.b3;

		b._a;
		b._b;
		b._c;
	}
};

代码段4：
class D :public C {
public:
	void test() {
		A a1;
		a1._a;
		//a1._b;
		//a1._c;

		B b2;
		b2._a;
		//b2._b;
		//b2._c;

		b2.b1;
		//b2.b2;
		//b2.b3;
	}
};

• 由代码段3可以看出，朋友只可以访问儿子的public级别，不能访问儿子的protected及以下级别，但是可以访问从父类继承过来的所有级别。
• 由代码段4得知，朋友的儿子不可以访问“我的”及其儿子的protected及以下级别，只能访问public。
• friend友元，如类C是类A的朋友，类C可以访问类A但是类A不可访问类C，即是友元关系是单向的不具有双向性。
• 友元关系不能继承。