第五周 继承
第一节 继承和派生
1.继承
继承是在定义一个新类B时，如果该类与某个已有类A相似（指B至少拥有A的全部特点），那么就把A作为一个基类，B作为基类的一个派生类。
派生类是通过对基类进行修改和扩充得到的。在派生类中，可以扩充新的成员变量和成员函数。派生类一经定义后，可以独立使用，不依赖于基类。
派生类拥有基类的全部成员函数和成员变量，不论是private、protected、public。但是在派生类的各个成员函数中，不能访问基类中的private成员。
派生类的写法：
class 派生类名: public 基类名
{
};
例程：
class CStudent{
private:
string sName;
int nAge;
public:
bool IsThreeGood(){};
void SetName(const string & name)
{sName = name;}
};
class CUndergraduateStudent: public CStudent{
private:
int nDepartment;
public:
bool IsThreeGood(){}//覆盖
bool CanBaoYan(){};
};
class CGraduatedStudent: public CStudent{
private:
int nDepartment;
char szMentorName[20];
public:
int CountSalary(){};
};
2.派生类对象的内存空间
派生类对象的体积，等于基类对象的体积再加上派生类对象自己的成员变量的体积。在派生类对象中，包含着基类对象，而且基类对象的存储位置位于派生类对象新增的成员变量之前。
完整程序如下：
#include <iostream>
#include <string>
#include <cstdlib>
using namespace std;
class CStudent {
private:
string name;
string id;
char gender;
int age;
public:
void PrintInfo();
void SetInfo(const string & name_, const string & id_, int age_, char gender_);
string GetName() { return name; }
};
class CUndergraduateStudent : public CStudent
{
private:
string department;
public:
void QualifiedForBaoyan() {
cout << “qualified for baoyan” << endl;
}
void PrintInfo() {
CStudent::PrintInfo();//因为我也要输出基类的信息，覆盖就没办法直接输出了，所以先调用下基类的该函数，如果是构造函数就可以直接省略，进行隐式方式调用
cout << “Department:” << department << endl;
}
void SetInfo(const string & name_, const string & id_, int age_, char gender_, const string & department_) {
CStudent::SetInfo(name_, id_, age_, gender_);
department = department_;
}
};
void CStudent::PrintInfo() {
cout << “Name:” << name << endl;
cout << “ID:” << id << endl;
cout << “Age:” << age << endl;
cout << “Gender:” << gender << endl;
}
void CStudent::SetInfo(const string & name_, const string & id_, int age_, char gender_) {
name = name_;
id = id_;
age = age_;
gender = gender_;
}
int main() {
CUndergraduateStudent s2;
s2.SetInfo(“Zhang Yushuai”, “011210149”, 23, ‘M’, “comunication”);
s2.QualifiedForBaoyan();
s2.PrintInfo();
system(“pause”);
return 0;
}
第二节 继承关系和复合关系
类与类的关系有三种：①没有关系；②继承关系；③符合关系。
继承：“是”的关系。基类A，B是基类A的派生类。逻辑上的要求：“一个B对象也是一个A对象”。
复合：“有”关系。
类C中“有”成员变量k，k是类D的对象，则C和D是符合关系。一般逻辑上的要求：D对象是C对象的固有属性或组成部分。
1.复合关系的使用
几何形体程序中，需要写“点”类，也需要写“圆类”，两者的关系就是复合关系——每一个圆对象里都包含一个点对象，即圆心。代码如下：
class CPoint{
double x,y;
friend class CCircle;
}
class CCicle{
double r;
CPoint center;//圆心
}
举例：写一个小区养狗管理程序，需要些一个业主类，还需要些一个狗来。而狗是由猪肉的，主人当然有业主。假定狗只有一个主人，但一个业主可以有最多10条狗。
写法：为“狗”类设一个“业主”类的对象指针；为“业主”类设一个“狗”类的对象指针数组。
class CMaster;
class CDog{
CMaster *pm;
};
class CMaster{
CDog *dogs[10];
};
图2.1 复合关系示意
第三节 覆盖和保护成员
1.覆盖
派生类可以定义一个和基类成员同名的成员，这叫覆盖。在派生类中访问这类成员时，缺省的情况是访问派生类定义的成员。要在派生类中访问由基类定义的同名成员时，要使用作用域符号::。
例如：
class base{
int j;
public:
int i;
void func();
};
class derived:public base{
public:
int i;
void access();
void func();
};
void derived::access(){
j = 5;//error
i = 5;//引用的是派生类的i
base::i = 6;//引用的是基类的i
func();//派生类的
base::func();//基类的
}
int main()
{
derived obj;
obj.i = 1;
base::obj.i = 2;
return 0;
}
一般来说，基类和派生类不定义同名成员变量，但同名成员函数很常见。
2.类的保护成员
（1）protected
基类的private成员，可以被下列函数访问：
①基类的成员函数；
②基类的友元函数
基类的public成员可以被下列函数访问：
①基类的成员函数；
②基类的友元函数；
③派生类的成员函数；
④派生类的友元函数；
⑤其它的函数。
基类的protected成员可以被下列函数访问：
①基类的成员函数；
②基类的友元函数；
③派生类的成员函数可以访问当前对象的基类的保护成员。
例子：
class Father{
private: int nPrivate;//私有成员
public: int nPublic;//公有成员
protected: int nProtected;//保护成员
};
class Son:public Father{
void AccessFather(){
nPublic = 1;//ok
nPrivate = 1;//wrong
nProtected = 1;//OK，访问从基类基础的Protected成员可以
Son f;
f.nProtected = 1;//wrong，f不是当前对象
}
};
int main(){
Father f;
Son s;
f.nPublic = 1;//ok
s.nPublic = 2;//ok
f.nProtected = 3;//error只能在本类的成员函数，派生类的成员函数，友元的成员函数访问
f.nPrivate = 4;//error基类的对象没办法访问基类的私有对象
s.nProtected = 5;//error派生类的对象无法访问基类的保护成员
s.nPrivate = 6;//error派生类的对象无法访问派生类从基类得到的私有成员
return 0;
}
第四节 派生类的构造函数
1.派生类的构造函数
class Bug{
private:
int nLegs;
int nColor;
public:
int nType;
Bug(int legs, int color);
void PrintBug(){};
};
class FlyBug:public Bug{
int nWings;
public:
FlyBug(int legs, int color, int wings);
};
Bug::Bug(int legs, int color)
{
nLegs = legs;
nColor = color;
}
FlyBug::FlyBug(int legs, int color, int wings):Bug(legs,color){
nWings = wings;
}
int main(){
FlyBug fb(2,3,4);
fb.PrintBug();
fb.nType = 1;
fb.nLegs = 2;//error无法直接访问私有成员
return 0;
}
其实派生类的构造函数大部分都很简单，和普通的构造函数一样，但是派生类的构造函数如何继承来自基类的私有成员呢？其实在第一节2的代码给了我们一个答案，就是如下，利用了初始化列表调用Bug类中的构造函数来实现，第一节2的代码是直接写在了代码块里面。
FlyBug::FlyBug(int legs, int color, int wings):Bug(legs,color){
nWings = wings;
}
这两种方式总结如下：
（1）显式方式：在派生类的构造函数中，为基类的构造函数提供参数。格式如下：
derived::derived(arg_derived-list):base(arg_base-list)
（2）隐式方式：在派生类的构造函数中，省略基类构造函数时，派生类的构造函数则自动调用基类的默认构造函数（无参构造函数，若不存在则报错）。
在创建派生类的对象时，需要调用基类的构造函数：初始化派生类对象中从基类继承的成员。在执行一个派生类的构造函数之前，总是先执行基类的构造函数。
派生类的析构函数被执行时，执行完派生类的析构函数后，自动调用基类的析构函数。
2.包含成员对象的派生类（封闭类）的构造函数写法
代码如下：
class Bug{
private:
int nLegs;
int nColor;
public:
int nType;
Bug(int legs, int color);
void PrintBug(){};
};
class Skill{
public:
Skill(int n){}
};
class FlyBug:public Bug{
int nWings;
Skill sk1,sk2;
public:
FlyBug(int legs, int color, int wings);
};
FlyBug::FlyBug(int legs, int color, int wings):Bug(legs,color),sk1(5),sk2(color),nWings(wings){}
（吐槽：都这么喜欢初始化列表，回头查查初始化列表仔细了解下）
3.封闭派生类对象的构造函数执行顺序
在创建派生类的对象时:
（1）先执行基类的构造函数，用以初始化派生类对象中从基类继承的成员；
（2）再执行成员对象类的构造函数，用以初始化派生类对象中成员对象；
（3）最后执行派生类自己的构造函数。
在派生类对象消亡时：
（1）先执行派生类自己的析构函数
（2）再依次执行各成员对象类的析构函数
（3）最后执行基类的析构函数
第五节 公有（public）继承的赋值兼容规则
1.public继承的赋值兼容规则
class base{};
class derived:public base{};//公有派生
base b;
derived d;
如上情况下，可以写出以下兼容规则：
（1）派生类的对象可以赋值给基类对象
b =d;//OK
（2）派生类对象可以初始化基类引用
base & br = d;
（3）派生类对象的地址可以赋值给基类指针，但是不能通过pb访问d对象中属于Derived类而不属于Base类的成员：
base *pb = &d;
这一切都是基于派生类对象就是一个基类对象的原因。
但是，如果派生方式是private或protected，则上述三条不可行。
2.protected继承和private继承
class base{};
class derived:protected base{};//公有派生
base b;
derived d;
protected继承时，基类的public成员和protected成员成为派生类的protected成员。
private继承时，基类的public成员成为派生类的private成员，基类的protected成员成为派生类的不可访问成员。
protected和private的继承不是“是”的关系。
3.基类与派生类的指针强制转换
通过强制指针类型转换，可以把ptrBase转换成Derived类的指针：
Base * ptrBase = &objDerived;
Derived *ptrDerived = (Derived * ) ptrBase;
4.直接基类和间接基类
A派生类B，类B派生类C，类C派生类D，……
– 类A是类B的直接基类
– 类B是类C的直接基类，类A是类C的间接基类
– 类C是类D的直接基类，类A、B是类D的间接基类
在声明派生类时，只需要列出它的直接基类：
（1）派生类沿着类的层次自动向上继承它的间接基类。
（2）派生类的成员包括：
①派生类自己定义的成员；
②直接基类中的所有成员；
③所有间接基类的全部成员。