inheritance.cpp

这我们老师对是面向对象程序设计（清华大学出版社）一书制作的PPT

#include <iostream.h>


//【例11.1】公有派生中各成员的访问权限。

class CBase
{
	int x;
protected:
	int y;
public:
	int z;
	CBase(int a,int b,int c)  {x=a;y=b;z=c;}
	int Getx(void)		{return x;}
	int Gety(void)		{return y;}
	void ShowBase(void)
	{	cout<<"x="<<x<<"\ty="<<y<<"\tz="<<z<<endl;	}
};

class CDerived:public CBase
{						  
	int Length,Width;
public:
	CDerived(int a,int b,int c,int d,int e):CBase(a,b,c)     //A
	{	
		Length=d;
		Width=e;
	}
	void Show(void)
	{	
		cout<<"Length="<<Length<<"\tWidth="<<Width<<endl;
		cout<<"x="<<Getx()<<"\ty="<<y<<"\tz="<<z<<endl;		//B	
	}
	int Sum(void)
	{	return Getx( )+y+z+Length+Width;	}
};

void main11_1(void)
{
	CDerived d1(1,2,3,4,5);
	d1.ShowBase();							//E
	d1.Show();
	cout<<"Sum="<<d1.Sum( )<<'\n';
	cout<<"y="<<d1.Gety()<<'\n';			    	//C
	cout<<"z="<<d1.z<<'\n';					//D
	
}



//【例11.2】 私有派生示例

class CBase2
{
protected:
	int a;
public:
	int b;
	void Set(int x,int y)
	{a=x;b=y;}
	void Show(void)
	{  cout<<a<<'\t'<<b<<endl;	}
};

class CDerived2:private CBase2
{	
public:
	void SetD(int x,int y)
	{Set(x,y);}
	void ShowD(void)
	{cout<<a<<'\t'<<b<<endl;
	}
};
class CDerived3:public CDerived2
{
public:
	void showd3()
	{
		//cout<<a<<endl;
		//cout<<b<<endl;
	}
};


void main11_2()
{
  	CBase2 b1;
	CDerived2 d1;
	cout<<sizeof(d1)<<endl;
	b1.Set(1,2);
	b1.Show();
	d1.SetD(10,100);
	d1.ShowD();
	CDerived3 d3;
	d3.showd3();
		

}


//【例11.3】 求圆柱体的体积。

#define PI 3.1415926

class CCircle
{
	float r;                         //圆半径
public:
	CCircle(float R)	{r=R;}
	float Getr(void)	{return r;}
};

class CRectangle
{
	float l, w;                        //长方体的长和宽
public:
	CRectangle(float L)	
	{  l=L;  }
	float Getl(void)
	{  return l;  }
};

class CColumn:public CCircle , public CRectangle
{
	double v;                        //圆柱体的体积
public:
	CColumn(float L,float W):CCircle(W/2),CRectangle(L)
	{  }
	void Volumn(void)
	{
		v=PI*Getr()*Getr()*Getl();
	}
	void ShowVolumn(void)
	{cout<<"Volumn="<<v<<'\n';}
};

void main11_3(void)
{
	CColumn col(7.5,4);
	col.Volumn();
	col.ShowVolumn();
}



//【例11.4】 派生类中构造函数和析构函数的调用顺序。

class CBase41
{
	int x;
public:
	CBase41(int a)
	{	
		x=a;
		cout<<"调用了基类1的构造函数!\n";
	}
	~CBase41(void)
	{	cout<<"调用了基类1的析构函数!\n";		}
};

class CBase42
{
	int y;
public:
	CBase42(int a)
	{	
		y=a;
		cout<<"调用了基类2的构造函数!\n";
	}
	~CBase42(void)
	{	cout<<"调用了基类2的析构函数!\n";		}
};

class CDerived4 : public CBase41,public CBase42		//A
{
	int z;
public:
	CDerived4(int a,int b,int c): CBase41(a), CBase42(b)	  //B  初始化基类成员
	{	
		z=c;
		cout<<"调用了派生类的构造函数!\n";
	}
	~CDerived4(void)
	{	cout<<"调用了派生类的析构函数!\n"; 	}
};

void main11_4(void)
{	
	CDerived4 d(2,4,6);	
}


//【例11.5】多层继承的基类成员的初始化

class A
{
protected:
	int x;
public:
	A(int a)
	{
		x=a;
		cout<<"调用了类A的构造函数\n";
	}
};

class B:public A
{
protected:
	int y;
public:
	B(int a,int b):A(a)
	{
		y=b;
		cout<<"调用了类B的构造函数\n";
	}
};

class C:public B
{
protected:
	int z;
public:
	C(int a,int b,int c):B(a,b)
	{
		z=c;
		cout<<"调用了类C的构造函数\n";
	}
};

void main11_5()
{	
	A a(1);
	B b(10,20);
	C c(100,200,300);	
}


//【例11.6】 派生类中包含对象成员。将例11.4中的派生类的定义作如下的修改：

class CDerived6 : public CBase41,public CBase42
{    
	int z;
	CBase41 b1,b2;
public:
	CDerived6(int a,int b,int c): CBase41(a), CBase42(b),b1(20),b2(a*b)	
	{	
		z=c;
		cout<<"调用了派生类的构造函数!\n";
	}
	~CDerived6(void)
	{	cout<<"调用了派生类的析构函数!\n"; 	}
};

void main11_6(void)
{	
	CDerived6 d(2,4,6);	
}


//【例11.7】 用访问声明调整访问类型

class CBase7
{
	int x;
protected:
	int y;
public:		
	int Fun(int a,int b)
	{
		cout<<a<<" "<<b<<endl;
		return a;}
};

class CDerived7:CBase7
{
protected :
   	//int CBase::y;         //错误，数据成员的访问声明中不能有类型
	CBase7::y;				//正确
public:		
	//int CBase::Fun(int,int);	//错误，成员函数的访问声明不能有参数和返回值类型
	CBase7::Fun;					//正确
};

void main11_7(void)
{	
	CDerived7 C;
	C.Fun(3,4);
}



//【例11.8】用访问声明调整重载函数的访问类型。

class CBase8
{
public:
	void Fun1(){}
	void Fun1(int x){}
	void Fun2(){cout<<"CBase8::Fun2()!\n";}
};

class CDerive8:CBase8
{
public:
	void Fun2(){cout<<"CDerive8::Fun2()!\n";}		//A
	CBase8::Fun1;		//B
	CBase8::Fun2;		//C
};

void main11_8()
{
		CDerive8 obj;
		obj.Fun2();
		//obj.CBase8::Fun2();          //D   错误
		obj.Fun1(5);
		obj.Fun1();
}


//【例11.9】冲突的程序示例。

class A9
{
protected:
	int x;
public:
	A9(int a){x=a;}
	void Show(void)
	{cout<<"x="<<x<<'\n';}
};

class B9
{
protected:
    int x;
public:
	B9(int a){x=a;}
	void Show(void)
	{cout<<"x="<<x<<'\n';}
};

class C9:public A9,public B9
{
	int y;
public:
	C9(int a , int b):A9(a) , B9(b){ }
	void Setx(int a)
	{
		//x=a;		//A  冲突
		A9::x=a;	//正确
	} 				
	void Sety(int b){y=b;}
	int Gety(void){return y;}
};

void main11_9(void)
{
	
	C9 c1(10,100);
    //c1.Show();			//B   冲突	

	c1.B9::Show();			//正确		 			   	 
}


//【例11.10】具有形如图11-4的类结构的冲突问题。

class B101
{
protected:
 	int x;
public:
	void Show()
	{cout<<"x="<<x<<'\n';}	
};
class B102
{
protected:
    int x;
public:
	void Show(){cout<<"x="<<x<<'\n';}	
};

class D101:public B101{  };
class D102:public B102{  };

class C10:public D102,public D101
{
public:
	//void SetX1(int a){D101::B101::x=a;}    //A  错误，域运算符不能连续使用
	void SetX1(int a){D101::x=a;}    //A 正确
	void SetX2(int a){D102::x=a;}       //B   正确，或为B2::x=a;
};

void main11_10(void)
{
	C10 c;
	c.SetX1(2);
	//c.D101::B101::Show();        //C  错误，域运算符不能连续使用
	c.B101::Show();
   	c.SetX2(3);
   	c.D102::Show();           //D   正确，或为c.B2::Show();
}


//【例11.11】成员覆盖示例

class B11
{
protected:
    int x;
public:    
	 void Show(void){cout<<"基类B中的x="<<x<<'\n';}
};
class D11:public B11				//E
{
protected:
    int x;
public:
	void Show()
	{cout<<"派生类D11中的x="<<x<<'\n';}
	void SetX(int a)
	{x=a;}					//F
	void SetBX(int a)
	{B11::x=a;}					//G
	void ShowB()
	{B11::Show(); }				//H
};

void main11_11(void)
{
	D11 c;
	c.SetX(20);
	c.SetBX(30);
	c.Show();	                //I
	c.B11::Show();              //J
}


//【例11.12】 赋值兼容规则

class CBase12
{
protected:
	int x;
public:
	CBase12(int a){x=a;}
	void Show1()
	{cout<<"x="<<x<<'\n';}
};

class CDerived12:public CBase12
{
protected:
	int y;
public:
	CDerived12(int a,int b):CBase12(b)
	{   y=a;   }
	void Show1()
	{cout<<"y="<<y<<'\n';}
	void Show2()
	{cout<<"y="<<y<<'\n';}
};

void main11_12()
{
	CDerived12 c(2,3);
	CBase12 b1(4),*b2;
	CBase12 &b3=c;     //A   派生类对象初始化基类引用
	b1=c;            //B   派生类对象赋给基类对象
	b2=&c;	        //C   派生类地址赋给基类指针
	b1.Show1();    	//D
	b2->Show1();		//E
	b3.Show1();		//F
	//c=b1;             //错误，不能将基类对象赋给派生类对象
    //b1.Show2();        //错误，不能访问派生类中增加的成员
    //b2->Show2();       //错误，理由同上
    //b3.Show2();        //错误，理由同上
}


//【例11.13】 使用虚基类，使派生类中只有基类的一个拷贝。

class CFurniture
{
protected:
	int weight;
public:
	CFurniture(){}
	void SetWeight(int i){weight=i;}
	int GetWeight(){return weight;}
};
class CBed:virtual public CFurniture     //A   定义虚基类
{ 
public:
	CBed(){}
	void Sleep()
	{cout<<"Sleeping...\n";}
};

class CSofa:virtual public CFurniture    //B   定义虚基类
{ 
public:
	CSofa(){}
	void WatchTV()
	{ cout<<"Watch TV. \n";}
};

class CSleepSofa:public CBed,public CSofa
{
public:
	CSleepSofa(){}
	void FoldOut()
	{cout<<"Fold out the sofa.\n";}
};

void main11_13()
{
	CSleepSofa ss;
	ss.SetWeight(20);				//C
	cout<<ss.GetWeight()<<'\n';		//D
}



//【例11.14】虚基类构造函数的调用次序

class CBase141
{
public:
	CBase141()
	{cout<<"This is CBase141 class!\n";}
};

class CBase142
{
public:
	CBase142(){cout<<"This is CBase142 class!\n";}
};

class CDerive141:public CBase142,virtual public CBase141
{
public:
	CDerive141()
	{cout<<"This is CDerive141 class!\n";}
};

class CDerive142:public CBase142,virtual public CBase141    //A
{
public:
	CDerive142()
	{cout<<"This is CDerive142 class!\n";}
};

class CTop:public CDerive141,virtual public CDerive142     //B
{
public:
	CTop()
	{cout<<"This is CTop class!\n";}
};

void main11_14()
{	CTop topObj;	}



//【例11.15】初始化虚基类成员
    		
class CBase15
{
	int x,y;
public:
	CBase15(int a,int b)
	{x=a,y=b;}
	void display(){cout<<"x="<<x<<";y="<<y<<endl;}
};

class CDerive151:virtual public CBase15    //A
{
public:
	CDerive151():CBase15(2,3){}
};

class CDerive152:virtual public CBase15    //B
{
public:
	CDerive152():CBase15(4,5){}
};

class CTop15:public CDerive151,public CDerive152
{
public:
	CTop15():CDerive152(),CDerive151(),CBase15(6,7){}       //C

};

void main()
{	
	CTop15 topObj;
	topObj.display();
}