注：该课程大纲详见 https://www.cnblogs.com/inchbyinch/p/12398921.html

1 继承和派生的概念

• 继承：在定义一个新的类B时，如果该类与某个已有的类A相似（指的是B拥有A的全部特点），那么就可以把A作为一个基类，而把B作为基类的一个派生类（也称子类）。


• 派生类是通过对基类进行修改和扩充得到的。在派生类中，可以扩充新的成员变量和成员函数。派生类一经定义后，可以独立使用，不依赖于基类。


• 派生类拥有基类的全部成员函数（除了构造和析构函数）和成员变量，不论是private、protected、public。


• 在派生类的各个成员函数中，不能访问基类中的private成员。


• 派生类对象的体积（内存空间），等于基类对象的体积，再加上派生类对象自己的成员变量的体积。在派生类对象中，包含着基类对象，而且基类对象的存储位置位于派生类对象新增的成员变量之前。


• 派生类可以定义一个和基类成员同名的成员，这叫覆盖。在派生类中访问这类成员时，缺省的情况是访问派生类中定义的成员。要在派生类中访问由基类定义的同名成员时，要使用作用域符号::。

2 类之间的关系

两种类关系：

• 继承：“是”关系，逻辑上要求：“一个B对象也是一个A对象”，比如人派生出男人、女人。


• 复合：“有”关系，一般逻辑上要求：“D对象是C对象的固有属性或组成部分”。

复合关系的案例：

• 汽车类包含轮胎类的成员对象；


• 点类和圆类；


• 小区养狗管理程序中“业主”类和“狗”类（每条狗都有一个主人，每个业主最多有10条狗）：业主类中定义一个狗类对象的指针数组，狗类中定义一个业主类对象的指针。

备注：也有资料说类之间的关系有三种，即is A, has A, uses A。

3 派生类的访问控制

派生类继承了基类的全部成员变量和成员方法（除了构造和析构之外的成员方法），但是这些成员的访问属性，在派生过程中是可以调整的。

（摘自C++ Primer）类的用户有三种：普通用户（通过对象访问）、类的实现者（通过类成员函数访问）、派生类。

3.1 单个类的访问控制

类成员访问级别（public、private、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 = 1; // Ok
f.nProtected = 1; // error
f.nPrivate = 1; // error
s.nProtected = 1; //error
s.nPrivate = 1; // error
return 0;
}

3.2 不同的派生方式会改变派生类成员的访问属性

• 派生访问说明符对于派生类的成员（及友元）是否能访问其直接基类的成员没啥影响，对基类成员的访问权限只与基类中的访问说明符有关。


• 派生访问说明符的目的是控制派生类用户（包括派生类的派生类在内）对于基类成员的访问权限。

4 派生类的构造与析构

继承中的构造析构调用原则：

• 子类对象在创建时会首先调用父类的构造函数；


• 父类构造函数执行结束后，执行子类的构造函数；


• 当父类的构造函数有参数时，需要在子类的初始化列表中显式的调用；


• 析构函数调用的先后顺序与构造函数相反。

继承与成员对象混搭情况下，构造和析构调用原则：

• 先构造父类，再构造成员对象，最后构造自己；


• 析构函数调用的先后顺序与构造函数相反。

5 public继承的赋值兼容规则

类型兼容规则是指在需要基类对象的任何地方，都可以使用公有派生类的对象来替代。通过公有继承，派生类得到了基类中除构造函数、析构函数之外的所有成员。这样，公有派生类实际就具备了基类的所有功能，凡是基类能解决的问题，公有派生类都可以解决。类型兼容规则中所指的替代包括以下情况：

• 子类对象可以当作父类对象使用


• 子类对象可以直接赋值给父类对象


• 子类对象可以直接初始化父类对象


• 父类指针可以直接指向子类对象


• 父类引用可以直接引用子类对象

在替代之后，派生类对象就可以作为基类的对象使用，但是只能使用从基类继承的成员。

类型兼容规则是多态性的重要基础之一。

//示例1：常用的类型兼容
class base { };
class derived : public base { };
base b;
derived d;
//派生类的对象可以赋值给基类对象： b = d;
//派生类对象可以初始化基类引用： base & br = d;
//派生类对象的地址可以赋值给基类指针： base * pb = & d;
//示例2：可以通过强制指针类型转换，把ptrBase转换成Derived类的指针
Base * ptrBase = &objDerived;
Derived * ptrDerived = (Derived * ) ptrBase;

注意：

• 如果派生方式是 private或protected，则上述三条不可行。


• 也可以通过强制指针类型转换，把ptrBase转换成Derived类的指针，但要保证ptrBase指向的是一个Derived类的对象，否则很容易会出错。

6 练习

//001:全面的MyString http://cxsjsxmooc.openjudge.cn/2019t3fall5/001/
//要求：编写MyString类
#include
#include
#include
using namespace std;
/*******************your code start here*****************/
class MyString{
char* p;
public:
MyString():p(new char[1]){ p[0]=0; } //构造函数
MyString(const char* p1); //构造函数
MyString(const MyString& s); //复制构造函数
~MyString(){ if(p) delete []p; } //析构函数
//定义功能函数
const char* c_str(){ return p; }
//重载运算符 =, +, +=, <, >, ==, <<, []
MyString& operator=(const char* p1);
MyString& operator=(const MyString& s);
friend MyString operator+(const char* p1, const MyString& s);
friend MyString operator+(const MyString& s1, const MyString& s2);
MyString& operator+=(const char* p1);
MyString operator()(int start, int len); //取子串
bool operator<(const MyString& s);
bool operator>(const MyString& s);
bool operator==(const MyString& s);
friend ostream& operator<<(ostream& o, const MyString& s);
char& operator[](int i);
};
MyString::MyString(const char* p1){
p = new char[strlen(p1)+1];
strcpy(p, p1);
}
MyString::MyString(const MyString& s){
p = new char[strlen(s.p)+1];
strcpy(p, s.p);
}
//重载运算符 =, +, <, >, ==, <<, []
MyString& MyString::operator=(const char* p1){ //MF：类外实现时忘加 类::
if(p) delete []p;
p = new char[strlen(p1)+1];
strcpy(p, p1);
return *this;
}
MyString& MyString::operator=(const MyString& s){
if(this==&s) return *this;
if(p) delete []p;
p = new char[strlen(s.p)+1];
strcpy(p, s.p);
return *this;
}
MyString operator+(const char* p1, const MyString& s){
MyString new_s;
new_s.p = new char[strlen(p1)+strlen(s.p)+1];
strcpy(new_s.p, p1);
strcpy(new_s.p+strlen(p1), s.p);
return new_s;
}
MyString operator+(const MyString& s1, const MyString& s2){
MyString new_s;
new_s.p = new char[strlen(s1.p)+strlen(s2.p)+1];
strcpy(new_s.p, s1.p);
strcpy(new_s.p+strlen(s1.p), s2.p);
return new_s;
}
MyString& MyString::operator+=(const char* p1){
char* temp = new char[strlen(p)+strlen(p1)+1];
strcpy(temp, p);
strcpy(temp+strlen(p), p1);
if(p) delete []p;
p = temp;
return *this;
}
MyString MyString::operator()(int start, int len){
//暂不做有效性检查
char* temp = new char[len+1];
for(int i=0; i temp[i] = p[start++];
temp[len] = 0;
MyString new_s(temp);
delete []temp;
return new_s;
}
bool MyString::operator<(const MyString& s){
if(strcmp(p, s.p) <0)
return true;
else
return false;
}
bool MyString::operator>(const MyString& s){
if(strcmp(p, s.p) > 0)
return true;
else
return false;
}
bool MyString::operator==(const MyString& s){
if(strcmp(p, s.p) == 0)
return true;
else
return false;
}
ostream& operator<<(ostream& o, const MyString& s){ //MF：ostream设成const,出错
o < return o;
}
char& MyString::operator[](int i){
if(i<0 || i>=strlen(p)){
cout <<"out of range." < exit(-1);
}
return p[i];
}
/********************code end here***********************/
int CompareString( const void * e1, const void * e2)
{
MyString *s1 = (MyString * ) e1;
MyString *s2 = (MyString * ) e2;
if( *s1 <*s2 )
return -1;
else if( *s1 == *s2)
return 0;
else if( *s1 > *s2 )
return 1;
}
int main(){
MyString s1("abcd-"),s2,s3("efgh-"),s4(s1);
MyString SArray[4] = {"big","me","about","take"};
cout <<"1. " < s4 = s3;
s3 = s1 + s3;
cout <<"2. " < cout <<"3. " < cout <<"4. " < cout <<"5. " < cout <<"6. " < s2 = s1;
s1 = "ijkl-";
s1[2] = &＃39;A&＃39; ;
cout <<"7. " < cout <<"8. " < s1 += "mnop";
cout <<"9. " < s4 = "qrst-" + s2;
cout <<"10. " < s1 = s2 + s4 + " uvw " + "xyz";
cout <<"11. " < qsort(SArray,4,sizeof(MyString),CompareString);
for( int i = 0;i <4;i ++ )
cout < //s1的从下标0开始长度为4的子串
cout < //s1的从下标5开始长度为10的子串
cout < return 0;
}