注：该课程大纲详见 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 <cstdlib>
#include <iostream>
#include <cstring>
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<len; 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 << s.p;
    return o;
}

char& MyString::operator[](int i){
    if(i<0 || i>=strlen(p)){
        cout << "out of range." << endl;
        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. " << s1 << s2 << s3<< s4<< endl;
    s4 = s3;
    s3 = s1 + s3;
    cout << "2. " << s1 << endl;
    cout << "3. " << s2 << endl;
    cout << "4. " << s3 << endl;
    cout << "5. " << s4 << endl;
    cout << "6. " << s1[2] << endl;
    s2 = s1;
    s1 = "ijkl-";
    s1[2] = 'A' ;
    cout << "7. " << s2 << endl;
    cout << "8. " << s1 << endl;
    s1 += "mnop";
    cout << "9. " << s1 << endl;
    s4 = "qrst-" + s2;
    cout << "10. " << s4 << endl;
    s1 = s2 + s4 + " uvw " + "xyz";
    cout << "11. " << s1 << endl;
    qsort(SArray,4,sizeof(MyString),CompareString);
    for( int i = 0;i < 4;i ++ )
        cout << SArray[i] << endl;
    //s1的从下标0开始长度为4的子串
    cout << s1(0,4) << endl;
    //s1的从下标5开始长度为10的子串
    cout << s1(5,10) << endl;
    return 0;
}

C++课程学习笔记第五周：继承

原文：https://www.cnblogs.com/inchbyinch/p/12398355.html