【C++ 系列笔记】03 C++ 面向对象进阶

Content

• C++ 面向对象进阶
• 继承 - 基础
• 继承中的对象模型
• 继承中的构造和析构
• 继承中的同名处理
• 不会继承的函数
• 继承 - 进阶
• 多继承
• 虚继承
• 多态 - 基础
• 静态多态和动态多态
• 动态多态原理解析
• 开闭原则
• 多态 - 进阶
• 纯虚函数和抽象类
• 虚析构和纯虚析构
• 类型转换
• 静态成员方法实现多态

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	| __private
   4	| __public
   8	| __protected
  	+---
  

  class Type	size(16):
  	+---
      |
   0	| +--- (base class Base)
   0	| | __private
   4	| | __public
   8	| | __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;
      // > 200
      
      cout << obj.Type::member << endl;
      // > 200
      cout << 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	| 0
   1	| 8 (Grandsond(Son1+0)Base) // 偏移量
  
  // Son2 的虚基表
  Grandson::$vbtable@Son2@:
   0	| 0
   1	| 4 (Grandsond(Son2+0)Base) // 偏移量
  vbi:	   class  offset o.vbptr  o.vbte fVtorDisp
            Base       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）：虚拟函数表，结构是一个数组

- 子类

```cpp
class Programmer	size(12):
	+---
    |  
 0	| +--- (base class Person)
 0	| | {vfptr} // 虚函数表指针
 4	| | member
	| +---
    |  
 8	| member
	+---

// 此处内存空间并不接壤

Programmer::$vftable@: // 虚函数表
	| &Programmer_meta
	|  0
 0	| &Programmer::speak

Programmer::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;
      };
  };
  

类型转换

• 未发生多态

  向下类型转换即子类指针指向父类实例，会导致指针寻址范围较大，不安全。

  向上类型转换是安全的。

• 发生了多态

  多态是父类的指针或引用指向了子类实例，此时一定是安全的。

静态成员方法实现多态

只有非静态成员方法可以被声明为虚拟的，那么静态成员看起来就无法实现多态，但实际上还是有方法的，这里提供一个思路：

通过虚函数包装静态成员方法

代码实现：

#include<iostream>
using namespace std;
class Person {
 public:
  int member;
  static void __speak() { cout << "I'm a person." << endl; }
  // 虚函数包装
  virtual void speak() { __speak(); }
};

class Programmer : public Person {
 public:
  int member;
  static void __speak() { cout << "Life is shot, I'm a programmer." << endl; }
  // 虚函数包装
  virtual void speak() { __speak(); }
};


void test(Person& glh) {
  glh.speak();
  // > "Life is shot, I'm a programmer."
}
int main() {
  Programmer glh;
  test(glh);

  system("pause");
  return 0;
}