一、继承访问权限测试



B以private方式继承A，尝试把A中的部分public成员提升为public。

设计类A具有public, protected, private等不同属性的成员函数或变量；

类A：

class A {
public: 
	int a1;
	int seta1()
	{
		a1 = 1;
		return a1;
	}
protected:
	int b1;
	int setb1()
	{
		b1 = 2;
		return b1;
	}
private:
	int c1;
	int setc1()
	{
		c1 = 3;
		return c1;
	}
};

类B通过public, protected, private等不同方式继承A，在类B的成员函数中测试访问A的成员函数或变量；

B以public，protect，private继承A

class B1:public A {
public:
	int Testa()
	{
		a1 = 4;
		return a1;
	}
	int Testb()
	{
		b1 = 5;
		return b1;
	}
};
class B2 :protected A {
public:
	int Testa()
	{
		a1 = 6;
		return a1;
	}
	int Testb()
	{
		b1 = 7;
		return b1;
	}
};
class B3 :private A {
public:
	int Testa()
	{
		a1 = 8;
		return a1;
	}
	int Testb()
	{
		b1 = 9;
		return b1;
	}
};

经测试无论用何种方法引用都无法在B中改变A中private的c的值，且编译无法通过，所以B中代码删除关于c操作的函数

测试：

int main()
{
	int n[3];
	B1 b1;
	B2 b2;
	B3 b3;
	n[0] = b1.Testa();
	n[1] = b1.Testb();
	cout << n[0] <<"," << n[1] << endl;
	n[0] = b2.Testa();
	n[1] = b2.Testb();
	cout << n[0] << "," << n[1] << endl;
	n[0] = b3.Testa();
	n[1] = b3.Testb();
	cout << n[0] << "," << n[1] << endl;
}

结果：

经测试不论用什么方法继承A在B中都可以访问到A中public和protected的变量

在类B中添加public, protected, private等不同属性的成员函数或变量，在外部测试访问B的各个成员函数或变量；

在外部测试访问B的各个成员变量只能访问public的，其他属性的成员不可访问

二、友元类继承测试

设计类A含有私有变量a，在类A中友元给类C；

class A {
private: 
	int a;
	friend class C;

};

设计类B继承A，添加私有变量b；在类C中测试访问类B的成员变量a, b;

class B :A{
private:
	int b;

};
class C {
public:
	int testa(B b)
	{
		return b.a;
	}
	int testb(B b)
	{
		return b.b;
	}

};

 

结论1：朋友不可访问儿子的protected以下级别，但可以访问从父类继承来的protected一下级别

设计类D继承C，在D的成员函数中测试访问类A的成员变量a，类B的成员变量a, b。

 

class D :C {
public:
	int testA(A a)
	{
		return a.a;
	}
	int testBa(B b)
	{
		return b.a;
	}
	int testBb(B b)
	{
		return b.b;
	}
};

 结论2:儿子不能访问父类友元的任何protected以下级别

 三、多态性综合运用
一般多态性函数：输入输出        参数完全一样，在父类中添加virtual；
特殊多态性函数：输入或输出参数在子类中是父类的指针或基类的引用，在子类中对于的是子类的指针或子类的引用；
析构函数的多态性；

#include<iostream>
using namespace std;
class man {
public:
	man() {};
	virtual ~man() {};
	virtual void buy() {
		cout << "全票" << endl;
	}
};
class student :virtual public man {
public:
	student() {};
	~student() {};
	void buy() {
		cout << "3/4票" << endl;
	}
};
class less_than_12 :virtual public man {
public:
	less_than_12() {};
	~less_than_12() {};
	void buy() {
		cout << "半票" << endl;
	}
};
class D :public less_than_12, public student {
public:
	D() {};
	~D() {};
	void buy() {
		cout << "1/4票" << endl;
	}
};

void piao(man& p)
{
	p.buy();
}

int main()
{
	man a;
	student b;
	less_than_12 c;
	D d;
	d.buy();
	d.student::buy();

	piao(a);
	piao(b);
	piao(c);
	piao(d);

	

}