C++实验二 —— 继承与多态

继承

一、 继承访问权限测试

1、代码部分

class A{
	public:
		A_a;
	protected:
		A_b;
	private:
		A_c;
			
};

class pub_B:public A{
	public:
		void test(){
		A_a=2;
		A_b=2;
		A_c=2;	//无法访问	
		}
		int pub_B_a;
	protected:
		int pub_B_b;
	private:
		int pub_B_c; 
};



class pro_B:protected A{
	public:
		 void test(){
		 A_a=2;
		 A_b=2;
		 A_c=2;	 //无法访问		
		 }
		 int pro_B_a;
	protecyed:
		 int pro_B_b;
	private:
		 int pro_B_c;
};



class B:private A{
	public:
		void test(){
		A_a=2;
		A_b=2;
		A_c=2;	 //无法访问		
		}
		int pri_B_a;
	protecyed:
		 int pri_B_b;
	private:
		 int pri_B_c;
};



void Test(){
pub_B b1;
	b1.A_a;
	b1.A_b;					//无法访问
	b1.A_c;						//无法访问
	b1.pub_B_a;
	b1.pub_B_b;			//无法访问
	b1.pub_B_c;				//无法访问
	
	
	pro_B b2;
	b2.A_a;                     //无法访问
	b2.A_b;					//无法访问
	b2.A_c;						//无法访问
	b2.pro_B_a;
	b2.pro_B_b;			//无法访问
	b2.pro_B_c;				//无法访问
	
	
	pri_B b3;
	b3.A_a;                        //无法访问
	b3.A_b;			     		//无法访问
	b3.A_c;						//无法访问
	b3.pri_B_a;               
	b3.pri_B_b;		        	//无法访问
	b3.pri_B_c;			     	//无法访问
}

2、总结

1、子类不管以何种方式继承基类，都无法访问基类的私有成员；

二、友元类继承测试

1、代码部分

#include<istream>
using namespace std;
class A {
private:
	int A_a;			//私有变量A_a
	friend class C;					//友元类C

};


class B :public A {			//类B继承类A
private:
	int B_b;								//私有变量B_b

};


class C {
public:
	void Test() {
		B b;
		C c;
		b.A_a;					//b继承A类
		
	}

};

class D :public  C{
public:
	void Test() {
		A a;				//创建对象A
		B b;				//创建对象B
	}

};

2、总结

在一个类中，利用关键friend将其他类声明为友元，称为友元类。

（1）在类A中，定义有私有变量a，将类C声明为A的友元类；
在类B中，定义有私有变量b，类B继承类A；
类C测试访问类B中，C可以访问到a，访问不到b；
总结：友元类C可以可以访问类A的私有成员。基类(A)的友元©不一定是子类的友元(B)

（2）在类D中,类D继承类C;
类D测试访问，访问不到类A的私有变量a，也访问不到类B的私有变量b
总结：友元关系不能够被继承

extra：
友元关系不能传递；
友元关系是单向的；

多态

三、多态性综合运用

1、虚函数的多态性：

代码部分：

#include<iostream>
using namespace std;

class animal{				//创建动物类 
	
	public:
		 void sleep(){
			cout<<"animal sleep"<<endl;		//动物睡觉 
		}
        virtual void breath(){						//动物呼吸 （虚函数） 
			cout<<"animal breath"<<endl;
		}
};

class fish:public animal{				//创建鱼类继承动物 
	
public:											
		void sleep(){
			cout<<"fish sleep"<<endl;		//鱼类睡觉 
		}
		void breath(){						//鱼类呼吸 
			cout<<"fish breath"<<endl;
		}
	
	
}; 


int main(){
	
	fish fh;				//创建鱼类对象 
	animal*A=&fh;
	A->sleep();					//测试
	A->breath();				//测试
} 

运行结果：

2、析构函数的多态性

代码部分：

#include<iostream>
using namespace std;

class animal{				//创建动物类 
	
	public:
		 animal (){								//构造函数 
		 	cout<<"animal constructor"<<endl; 
		 } 
		
		virtual ~animal (){							//虚析构函数 
		 	cout<<"animal destructor"<<endl;
		 } 
		 
		 void sleep(){
			cout<<"animal sleep"<<endl;		//动物睡觉 
		}
		
        virtual void breath(){						//动物呼吸 （虚函数） 
			cout<<"animal breath"<<endl;
		}
};

class fish:public animal{				//创建鱼类继承动物 
	
public:											
       	fish (){								//构造函数 
		 	cout<<"fish constructor"<<endl;
		 } 
		
		 ~fish (){							//析构函数 
		 	cout<<"fish destructor"<<endl;
		 
		 } 
	
		void sleep(){
			cout<<"fish sleep"<<endl;		//鱼类睡觉 
		}
		void breath(){						//鱼类呼吸 
			cout<<"fish breath"<<endl;
		}
	
}; 



int main(){
	
	fish fh;				//创建鱼类对象 
	animal*A=&fh;
	A->sleep();
	A->breath();
	delete A; 					//销毁指针
} 

运行结果：