第5章 【例题】（部分~）

【例5.1】使用继承的案例

//【例5.1】使用继承的案例
#include <iostream>
#include <string>
using namespace std;
class Person{	//声明基类
	public:
		Person(string name1,string id_number,int age1);
		~Person();
		void show();	//在基类中定义了成员函数show()
	private:
		string name;	//姓名
		string id_number;	//身份证号
		int age;	//年龄
};
Person::Person(string name1,string id_number1,int age1)
{
	name=name1;
	id_number=id_number1;
	age=age1;
}
Person::~Person()
{
}
void Person::show()
{
	cout<<"\n 姓名："<<name;
	cout<<"\n 身份证号："<<id_number;
	cout<<"\n 年龄："<<age;
}
class Student:public Person{	//声明公有派生类Student
	public:
		Student(string name1,string id_number1,int age1,int credit1);
		~Student();
		void show();	//在派生类中，重新定义了成员函数show()
	private:
		int credit;		//学分
};
Student::Student(string name1,string id_number1,int age1,int credit1)
	:Person(name1,id_number1,age1)	//定义派生类构造函数时，缀上基类的构造函数
{
	credit=credit1;
}
Student::~Student()
{
}
void Student::show()
{
	Person::show();	//调用基类Person的成员函数show()
	cout<<"\n 学分："<<credit<<endl;
}
int main()
{
	Student stu1("黎明","110105**********63",19,166);
	stu1.show();	//调用的是派生类中的成员函数show()
	//stu1.Person::show();//不妨加上这条语句，是可以通过对象访问基类的公有成员的，因为是公有继承
	return 0;
}

?

【例5.2】一个私有继承的例子?

//【例5.2】一个私有继承的例子
#include <iostream>
#include <string>
using namespace std;
class Person{	//声明基类
	public:
		Person(int age1)
		{	age=age1;	}
		void setage(int age1)
		{	age=age1;	}
		void show();	//在基类中定义成员函数show()
	private:
		int age;		//年龄
};
void Person::show()
{
	cout<<"年龄："<<age<<endl;
}
class Student:private Person{	//声明私有派生类Student
	public:
		Student(int age1,int credit1);
		void setage_cre(int a1,int c1)
		{
			setage(a1);	//基类的setage()函数在派生类中为私有成员，派生类成员函数可以访问
			credit=c1;	//正确，成员函数setage_cre()可以访问本类的私有成员credit
		}
		void show();	//在派生类中，重新定义了成员函数show()
	private:
		int credit;		//学分
};
Student::Student(int age1,int credit1):Person(age1)	//定义派生类构造函数时，缀上基类的构造函数
{
	credit=credit1;
}
void Student::show()
{
	Person::show();		//调用基类的show()函数显示年龄
	cout<<"学分："<<credit<<endl;
}
int main()
{
	Student stu1(19,166);
	stu1.setage_cre(20,168);	//正确，setage_cre在类Student为公有成员，派生类对象能访问。
	stu1.show();				//调用的是派生类中的成员函数公有成员show()，派生类对象能访问。
	//stu1.Person::show();		//加上这条语句错误！因为是私有继承，基类所有成员在派生类中为私有,
								//不可通过派生类的对象直接访问.
	return 0;
}

【例5.3】基类中的保护成员以私有的方式被继承后的访问属性?

//【例5.3】基类中的保护成员以私有的方式被继承后的访问属性
#include <iostream>
#include <string>
using namespace std;
class Person{	//声明基类
	public:
		Person(int age1)
		{	age=age1;	}
		void setage(int age1)
		{	age=age1;	}
		void show();	//在基类中定义成员函数show()
	protected:
		int age;		//年龄
};
void Person::show()
{
	cout<<"年龄："<<age<<endl;
}
class Student:private Person{	//声明私有派生类Student
	public:
		Student(int age1,int credit1);
		void setage_cre(int a1,int c1)
		{
			setage(a1);	//基类的setage()函数在派生类中为私有成员，派生类成员函数可以访问
			//可以改写成:age=a1;	因为age在person中为protected,私有继承过来可以被访问
			credit=c1;	//正确，成员函数setage_cre()可以访问本类的私有成员credit
		}
		void show();	//在派生类中，重新定义了成员函数show()
	protected:
		int credit;		//学分
};
Student::Student(int age1,int credit1):Person(age1)	//定义派生类构造函数时，缀上基类的构造函数
{
	credit=credit1;
}
void Student::show()
{
	cout<<"年龄："<<age<<endl;	//可以访问基类的protected成员
	cout<<"学分："<<credit<<endl;
}
class PostGraduate:private Student{	//声明私有派生类PostGraduate
	public:
		PostGraduate(int age1,int credit1,float subsidy1):Student(age1,credit1)
										//定义派生类构造函数时，缀上基类的构造函数
		{
			subsidy=subsidy1;
		}
		void setall(int age1,int credit1,float subsidy1)
		{
			setage_cre(age1,credit1);
			subsidy=subsidy1;
		}
		void show()
		{
			Student::show();	//可以访问
			//cout<<"年龄："<<age<<endl;		//不可访问,age在person类中是protected,被Student派生后成为private
			cout<<"学分："<<credit<<endl;	//可访问,credit在Student中为protected
			cout<<"补助："<<subsidy<<endl;	//可以访问本类私有成员
		}
		private:
			float subsidy;	//补助
};
int main()
{
	PostGraduate PG1(24,29,3000.00);
	PG1.show();
	PG1.setall(24,29,3500.00);
	PG1.show();
	return 0;
}

?

?【例 5.4】基类和派生类的构造函数及析构函数的调用顺序

//【例 5.4】基类和派生类的构造函数及析构函数的调用顺序
#include <iostream>
using namespace std;
class B {//声明基类B
	public:
		B(){
			cout<<"B类构造函数使用中"<<endl;
		}
		~B(){
			cout<<"析构函数B类对象"<<endl;
		}
};
class D:public B{//基类B的公有派生类D
	public:
		D(){//派生类的构造函数
			cout<<"D类对象构造中"<<endl;
		}
		~D(){
			cout<<"析构D类对象"<<endl;
		}
};
int main()
{
	D op;
	return 0;
}

?

知识点：
1.构造函数的调用顺序
先调用基类的构造函数，后调用派生类的构造函数
2.析构函数的调用顺序（与构造函数的调用顺序正好相反）
先调用派生类的析构函数，后调用基类的析构函数

【例5.5】当基类含有带参构造函数时，派生类构造函数和析构函数的构造方法

//【例5.5】当基类含有带参构造函数时，派生类构造函数和析构函数的构造方法
#include <iostream>
using namespace std;
class B{	//声明基类B
	public:
		B(int n)	//基类构造函数
		{
			cout<<"B类对象构造中"<<endl;
			i=n;
		}
		~B()		//基类析构函数
		{
			cout<<"析构B类对象"<<endl;
		}
		void dispi()
		{
			cout<<i<<endl;
		}
	private:
		int i;
};
class D:public B{	//声明基类B的公有派生类
	public:
		D(int n,int m):B(m)	//定义派生类构造函数时
		{					//缀上要调用的基类构造函数及其参数
			cout<<"D类对象构造中"<<endl;
			j=n;
		}
		~D()				//派生类的析构函数
		{
			cout<<"析构D类对象"<<endl;
		}
		void dispj()
		{
			cout<<j<<endl;
		}
	private:
		int j;	
};
int main()
{
	D obj(50,60);
	obj.dispi();
	obj.dispj();
	return 0;
}

??