继承

继承的基本概念和语法

1. 子类继承基类，基类派生子类，子类IsA基类。
2. class 子类名 : 继承方式描述符1 基类名1, 继承方式描述符2 基类名2, ...
   {
   };

class Staff
{
}
class SoftwareEngineer:public Staff
{
}
class ProductManager:public Staff
{
}

3. 继承方式：公有继承(public)、保护继承(protected)、私有继承(private)。

范例:Staff.cpp

公有继承

1. 一个子类类型的对象在任何时候都可以作为一个基类类型的对象，而不必使用显示的类型转换，前提是两者（子类及其基类）都是通过指针或引用操作的。
   

   示意图
   范例:Staff02.cpp

2. 我们在子类中可以直接使用基类的所有公有和保护成员，就象它们是在子类中声明的那样，但基类的私有成员在子类中虽然存在却不可见，故无法直接使用。

class A
{
      string name;
};
//
class B
{
      int age
public:
      B()
      {
        #error 子类不能访问父类中的私有成员。
        this->name = "wxx";
      }
};

3. 尽管基类的公有和保护成员在子类中直接可见，但我们也可以在子类中重新定义这些名字。由此产生的名字冲突可以通过“子类中的名字定义隐藏所有基类中的同名定义”规则而避免。如果需要在子类中使用一个在基类中定义却被子类的同名定义所隐藏的名字，我们可以使用作用域分解操作符“::”来达到这个目的。

#include <iostream>
#include <string>
using namespace std;
class Human
{
public:
    string m_name;
protected:
    int m_age;
public:
    Human(string name,int age):m_name(name),m_age(age)
    {
    }
};
class Person:public Human
{
private:
    string m_name;
    int m_age;
public:
    Person(string name,int age):Human(name+"Human",age-10),m_name(name),m_age(age)
    {
    }
    void show()
    {
        cout<<"Person:\n"<<m_name<<"\t"<<m_age<<endl;
        cout<<"Human:\n"<<Human::m_name<<"\t"<<Human::m_age<<endl;
    }
};
int main(int argc,char** argv)
{
    Person p("wxx",100);
    p.show();
    return 0;
}

继承方式对成员访问控制的影响

• 类成员的访问控制

访控限定符	访控属性	基类	子类	外部	友元
public	公有成员	✅	✅	✅	✅
protected	保护成员	✅	✅	❌	✅
private	私有成员	✅	❌	❌	✅

AcessControl.cpp、AcessControl02.cpp

• 基类中的公有、保护和私有成员，在其公有、保护和私有子类中的访控属性，因继承方式而异。

基类中的	public继承	protected继承	private继承
public member	public	protected	private
protected member	protected	protected	private
private member	private	private	private

AcessControl.cpp

子类的构造与析构函数

1. 子类隐式调用基类构造函数
   范例：impbase.cpp

如果子类的构造函数没有显式地调用其基类的构造函数，那么系统将会调用其基类的无参构造函数。但是请注意，只有在我们为基类显式地提供一个无参构造函数，或者不提供任何构造函数（系统会提供一个缺省的无参构造函数）的情况下，基类才拥有无参构造函数。This is some text!

2. 子类显式调用基类构造函数
   范例：expbase.cpp

每个子类的实例化对象中都包含其基类的实例化子对象，即子类对象的基类部分。该子对象是由基类的构造函数创建并初始化的。

3. 继承链的构造和析构顺序

• 子类的析构函数在执行完其中的析构代码,并析构完所有的成员变量以后,会自动调用其基类的析构函数,析构该子类对象中的基类子对象。
• 通过基类指针析构子类对象,实际被析构的仅仅是子类对象中的基类子对象,子类的扩展部分将失去被析构的机会,极有可能形成内存泄漏
  构造:先基类后子类
  析构:先子类后基类
  范例：ConstructorDestructorOrder.cpp

4. 基类分配资源，基类提供析构，子类未分配资源，子类无需提供析构
   范例：DestructorOrder01.cpp

5. 基类分配资源，基类提供析构，子类亦分配资源，子类必须提供析构
   范例：DestructorOrder02.cpp

6. 通过基类指针析构子类对象的问题
   范例：DestructorOrder03.cpp＃error 这是一个错误例子。
   图示：
   

   基类指针析构子类对象

通过基类指针析构子类对象,实际被析构的仅仅是子类对象中的基类子对象,子类的扩展部分将失去被析构的机会,极有可能形成内存泄漏

子类的拷贝构造与拷贝赋值

1. 子类没有定义拷贝赋值运算符函数，编译器为子类提供的缺省拷贝赋值运算符函数,会自动调用其基类的拷贝赋值运算符函数，复制该子类对象中的基类子对象。

2. 子类定义了拷贝赋值运算符函数,但没有显式调用其基类的拷贝赋值运算符函数，子类对象中的基类子对象将得不到复制。

3. 子类定义了拷贝赋值运算符函数，同时显式调用了其基类的拷贝赋值运算符函数，子类对象中的基类部分和扩展部分一起被复制。
   参考：copy.cpp、copy02.cpp

子类的操作符重载

• 在为子类提供操作符重载定义时,往往需要调用其基类针对该操作符所做的重载定义,完成部分工作

• 通过将子类对象的指针或引用向上造型为其基类类型的指针或引用,可以迫使针对基类的操作符重载函数在针对子类的操作符重载函数中被调用

friend ostream& operator<<(ostream& os,const Truck& truck)
{
    os<<(Car&)truck<<","<<truck.m_maxCargoWeight; //OK
    // os<<(Car)truck<<","<<truck.m_maxCargoWeight; //OK
    return os;
}

参考:operator.cpp

名字隐藏与重载

1. 继承不会改变类成员的作用域,基类的成员永迖都是基类的成员,并不会因为继承而变成子类的成员。

2. 因为作用域的不同,分别在子类和基类中定义的同名成员函数(包括静态成员函数),并不构成重载关系,相反是一种隐藏关系,除非通过using声明将基类的成员函数引入子类的作用域,形成重载。

3. 任何时候,无论在子类的内部还是外部,总可以通过作用域限定操作符“::”,显示地调用那些在基类中定义却为子类所隐藏的成员函数

私有继承与保护继承

1. 私有继承亦称实现继承,旨在于子类中将其基类的公有和保护成员私有化,既禁止从外部通过该子类访问返些成员,也禁止在该子类的子类中访问返些成员

2. 保护继承是一种特殊形式的实现继承,旨在于子类中将其基类的公有和保护成员迕行有限的私有化,叧禁止从外部通过该子类访问返些成员,但并不禁止在该子类的子类中访问返些成员

3. 私有子类和保护子类类型的指针或引用,不能隐式转换为其基类类型的指针或引用
   参考：1、2、3

多重继承

在前面的例子中，子类都只有一个基类，称为单继承。除此之外，C++也支持多继承，即一个子类可以有两个或多个基类。

好像然并卵的样子，继承树越复杂越难以维护，Objective-c和Java中都没有这样的特性。了解即可(撸主不用这样的玩意)。

多重继承语法使用“,”(英文逗号分割)。就像这样：

//🐶
class Dog
{  
};
//狮子
class Lion
{
};
//狮子🐶，呵呵。
class LionDog:public Lion,public Dog
{
};

多重继承下的构造函数

多继承的子类和单继承的子类构造函数基本相同，如下。至于基类排序顺序随意。构造时的顺序按照基类排序顺序，先基类后子类。

LionDog(/*参数列表*/): Dog(/*参数列表*/), Lion(/*参数列表*/)
{
//初始化
}

多重继承内存示意图：

l_i1.png
参考：code

多重继承二意性

场景：Staff中有成员std::string name,Leader中也有成员std::string name，当HRLeader类继承Staff和Leader。如果子类中没做隐藏，那么就会产生二义性。
例子:code

虚基类

多继承时很容易产生命名冲突，即使我们很小心地将所有类中的成员变量和成员函数都命名为不同的名字，命名冲突依然有可能发生，比如非常经典的菱形继承层次。如下图所示：

非虚继承

在一个子类中保留间接基类的多份同名成员，虽然可以在不同的成员变量中分别存放不同的数据，但大多数情况下这是多余的：因为保留多份成员变量不仅占用较多的存储空间，还容易产生命名冲突，而且很少有这样的需求。

为了解决这个问题，C++提供了虚基类，使得在派生类中只保留间接基类的一份成员。

虚继承

参考：Code