C++ 面向对象进阶

继承 - 基础

class Base;
class Type :public Base{public:Type(a, b, c):Base(a, b){// ...}
};

• 继承方式（ 派生类均不可访问基类私有成员 ）

  • public（父类访问权限不变）

    最常用的方式

  • private（父类访问权限全变成私有）

    当不希望本类对象访问基类任何成员时，可以考虑使用 private 继承。

  • protected（父类访问权限全变成保护）

    使用 private 继承存在一个严重的问题：

    当该派生类进一步派生时，该子类将完全无法访问其父类成员。

    故一般使用 protected 进行派生，保证该派生类的可派生特性。

继承中的对象模型

• 类结构

  class Base{private:int __private;public:int __public;protected:int __protected;
  };
  class Type :public Base{public:int __sonPublic;
  };
  

• 内存结构

  class Base	size(12):+---0	| __private4	| __public8	| __protected+---
  

  class Type	size(16):+---|0	| +--- (base class Base)0	| | __private4	| | __public8	| | __protected| +---|12	| __sonPublic+---
  

继承中的构造和析构

• 调用父类构造

  class Base{private:int member;public:Base(m): member(m){// ...}
  };
  class Type :public Base{private:int sonMember;public:Type(m, m1):Base(m), sonMember(m1){// ...}
  };
  

  不显式地调用父类构造时，会隐式调用默认的无参构造。

• 调用顺序

  • 父类构造（多继承按照顺序构造）
  • 本类构造
  • 本类析构
  • 父类析构（多继承按照反序析构）

继承中的同名处理

• 同名属性

  class Base{public:int member;Base(m): member(m){}
  };
  class Type :public Base{public:int member;Type(m, m1):Base(m), member(m1){}
  };
  int main(){Type obj(100, 200);cout << obj.member << endl;// > 200cout << obj.Type::member << endl;// > 200cout << obj.Base::member << endl;// > 100
  }
  

  当直接引用该同名成员属性时，会隐式调用本类的成员属性。

  也可以通过作用域运算符显式地指定成员属性。

• 同名方法

  class Base{public:void fun();
  };
  class Type :public Base{public:// 子类重载void fun(int a);
  };
  int main(){Type obj;obj.fun();// 报错obj.fun(1);// 调用正常
  }
  

  子类重载了父类的方法，父类的方法将被隐藏，无法通过重载调用。

  想调用父类方法，可以通过作用域运算符显式指定。

不会继承的函数

• 构造和额析构函数
• 等号操作符重载函数

继承 - 进阶

多继承

class Base1 {// ...
};
class Base2 {// ...
};class Type: public Base1, public Base2 {// ...
};

• 多继承的二义性

  通过作用域访问不同父类的成员。

  class Base1 {public:int member;
  };
  class Base2 {public:int member;
  };class Type: public Base1, public Base2 {// ...
  };int main(){Type obj;obj.member;// 报错，存在多个父类的 member// 通过作用域访问obj.Base1::member;obj.Base2::member;
  }
  

虚继承

• 引出 - 菱形继承

  Grandson 的实例中存在两份基类实例的数据。

  class Base {public:int member;
  };class Son1: public Base {// ...
  };
  class Son2: public Base {// ...
  };class Grandson: public Son1, public Son2 {// ...
  };int main(){}
  

  内存结构

  这两份基类数据均可由不同的作用域访问到，且是相互独立的。

  class Grandson	size(8):+---|0	| +--- (base class Son1) // 父类| |   0	| | +--- (base class Base) // 基类0	| | | member // 两份基类实例数据| | +---| |   | +---|4	| +--- (base class Son2) // 父类| | 4	| | +--- (base class Base) // 基类4	| | | member // 两份基类实例数据| | +---| |   | +---|  +---
  

  为了解决这个问题，使用虚继承

• 虚继承

  当一个类对父类的继承被声明为虚拟的（virtual），它就成为了一个 虚基类。

  这里的 虚基类 是指该派生类继承自的基类是虚拟的，而不是说该派生类类是基类。

  class Base {public:int member;
  };// 虚基类
  class Son1 : virtual public Base {// ...
  };
  // 虚基类
  class Son2 : virtual public Base {// ...
  };class Grandson : public Son1, public Son2 {// ...
  };
  

  内存结构

  class Grandson	size(12):+---|0	| +--- (base class Son1) // 父类0	| | {vbptr} // 虚基指针| +---|4	| +--- (base class Son2) // 父类4	| | {vbptr} // 虚基指针| +---|+---+--- (virtual base Base) // 基类8	| member+---// 此处的内存空间并不接壤// Son1 的虚基表
  Grandson::$vbtable@Son1@:0	| 01	| 8 (Grandsond(Son1+0)Base) // 偏移量// Son2 的虚基表
  Grandson::$vbtable@Son2@:0	| 01	| 4 (Grandsond(Son2+0)Base) // 偏移量
  vbi:	   class  offset o.vbptr  o.vbte fVtorDispBase       8       0       4 0
  

  可以看到，原本存放基类实例的内存空间被一个 {vbptr} 占用了。

  vbptr（virtual base pointer）：虚拟基类指针

  该指针指向一个 vbtable

  vbtable（virtual base table）：虚拟基类表，结构是一个数组

  这个表中记录着 该虚基指针所在派生类实例与基类实例的偏移量。

  注意！虚基表的内存空间与类实例并不接壤。

  尝试取到该虚基表：

  Grandson obj;// Son1 的虚基表数组
  cout << ((int*)*((int*)&obj)) << endl;
  // Son2 的虚基表数组
  cout << ((int*)*((int*)&obj + 1)) << endl;
  

多态 - 基础

静态多态和动态多态

• 静态多态

  编译时多态，静态联编，包括函数重载在内的多态。

• 动态多态

  运行时多态，动态联编，通过虚函数实现的多态。

静态和动态多态的本质区别就是 静态联编 和 动态联编。

分别指在编译时绑定函数入口和在运行时寻找函数入口。

动态多态的本质：父类的引用或指针指向了子类对象。从而发生动态多态。

静态联编的例子：

class Person {public:int member;void speak() {cout << "I'm a person." << endl;}
};class Programmer: public Person {public:int member;void speak() {cout << "Life is shot, I'm a programmer." << endl;}
};void doSpeak(Person& person){person.speak();
}
int main(){Programmer programmer;doSpeak(programmer);// > "I'm a person."
}

I’m a person.

doSpeak 函数的实现在编译期就已经确定了需要调用的方法。

要实现动态多态，只需将基类的方法声明为虚拟的。

virtual void speak() {cout << "I'm a person." << endl;
}

Life is shot, I’m a programmer.

动态多态原理解析

重复一遍

动态多态的本质：父类的引用或指针指向了子类对象。从而发生动态多态。

上例静态联编的例子，其内存结构如下：

class Programmer	size(8):+---|  0	| +--- (base class Person)0	| | member| +---|  4	| member+---

现在将基类的 speak 方法声明为虚拟的：

class Person {public:int member;// 声明为虚拟的virtual void speak() {cout << "I'm a person." << endl;}
};class Programmer: public Person {public:int member;void speak() {cout << "Life is shot, I'm a programmer." << endl;}
};void doSpeak(Person& person){person.speak();
}
int main(){Programmer programmer;doSpeak(programmer);// > "Life is shot, I'm a programmer."
}

内存结构

• 父类

  class Person	size(8):+---0	| {vfptr} // 虚函数表指针4	| member+---// 此处内存空间并不接壤Person::$vftable@: // 虚函数表| &Person_meta|  0
  

0 | &Person::speak

Person::speak this adjustor: 0

可以发现，基类实例多了一个 {vfptr}**vfptr**（virtual function pointer）：虚拟函数表指针虚函数表指针指向一张虚函数表**vftable**（virtual function table）：虚拟函数表，结构是一个数组- 子类```c++
class Programmer	size(12):+---|  0	| +--- (base class Person)0	| | {vfptr} // 虚函数表指针4	| | member| +---|  8	| member+---// 此处内存空间并不接壤Programmer::$vftable@: // 虚函数表| &Programmer_meta|  00	| &Programmer::speakProgrammer::speak this adjustor: 0

子类继承后会创建一个新表，该表内会指向基类的虚函数。

若子类重新实现了某些虚函数 ，该表中被重新实现的函数将被覆盖，指向新函数的入口。

这种 重新实现 被称为 重写。被重写的函数的参数列表和返回值类型需要对应完全相同。

尝试取到该函数并调用：

Programmer programmer;((void (*)())*(int*)*(int*)&programmer)();
// > Life is shot, I'm a programmer.

开闭原则

即对扩展开放，对修改关闭。

修改需求并不应去修改实现，而应对原有类进行派生，重写方法，最后通过多态实现需求。

方便维护方便扩展。

由此引出抽象类。

多态 - 进阶

纯虚函数和抽象类

纯虚函数就是没有定义的函数，仅作为一个接口，为子类重写占位，实现多态。

class Type (){public:// 纯虚函数virtual voie fun() = 0;
};

virtual voie fun() = 0;告诉编译器在 vftable （虚函数表）中保留一个位置，但不放地址。

当一个类中含有纯虚函数时，这个类就被称为 抽象类，无法进行实例化。

且其派生类必须实现该纯虚函数。

虚析构和纯虚析构

• 虚析构

  当父类实例指针指向子类实例时，该子类实例析构会调用父类析构。

  如果子类需要在堆区开辟空间，那么析构时就会造成内存泄漏。

  class Base () {public:~Base(){};
  };
  class Son (): public Base {public:char* mName;Son(const char* name){// 构造时在堆区托管了额数据this->mName = new char[strlen(name)];strcpy(this->mName, name);}~Son(){// 析构时释放堆区数据delete[] this->mName;};
  };
  

  当 Son 类实例析构时，会调用其父类 Base 的析构函数，导致mName没有正确释放，从而导致内存泄漏。

  为了解决这个问题，我们就要使用 虚析构，让子类重写析构。

  virtual ~Base(){};
  

  注意！父类虚构是一定会调用的，尽管将父类析构声明为虚拟的，父类也需要做收尾工作。

• 纯虚析构

  与纯虚函数类似，当一个类中存在纯虚析构时，该类也是一个抽象类，无法实例化。

  但有一点稍稍不同，首先，作为抽象类需要派生才能使用，但任意一个派生类对象在释放时一定会调用父类的构造。

  所以 纯虚析构要求有定义，在类内声明，在类外定义。

  class Base () {public:virtual ~Base() = 0;// 纯虚析构的声明
  };
  Base::~Base(){// 纯虚析构的定义
  }
  class Son (): public Base {public:char* mName;Son(const char* name){// 构造时在堆区托管了额数据this->mName = new char[strlen(name)];strcpy(this->mName, name);}~Son(){// 析构时释放堆区数据delete[] this->mName;};
  };