【例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;
}
