虚析构函数

◼ 如果存在父类指针指向子类对象的情况，应该将析构函数声明为虚函数（虚析构函数）

• delete父类指针时，才会调用子类的析构函数，保证析构的完整性

image-20210407085700472

struct Animal {
    int m_age;
   virtual void speak() {
      cout << "Animal::speak()" << endl;
   }
    virtual void run() {
      cout << "Animal::run()" << endl;
   }

   Animal() {
      cout << "Animal::Animal()" << endl;
   }

   ~Animal() {
      cout << "Animal::~Animal()" << endl;
   }
};

struct Cat : Animal {
    int m_life;
   void speak() {
      cout << "Cat::speak()" << endl;
   }
   void run() {
      cout << "Cat::run()" << endl;
   }

   Cat() {
      cout << "Cat::Cat()" << endl;
   }

   ~Cat() {
      cout << "Cat::~Cat()" << endl;
   }
};

Animal *cat = new Cat();
cat->m_age = 20;
cat->speak();
cat->run();
delete cat;
//运行结果
Animal::Animal()
Cat::Cat()
Cat::speak()
Cat::run()
Animal::~Animal()

可以看到，只调用了Animal的析构方法，没有调用子类cat的析构。这其实也很好理解，由于Animal的析构方法非virtual虚函数类型，所以定义为

Animal *cat类型的指针，在调用方法时，只根据类型信息来调用对应的函数。

image-20210407090547359

virtual ~Animal() {
   cout << "Animal::~Animal()" << endl;
}

image-20210407090707562

给Animal的~Animal为虚函数，virtual ~Animal()虚析构函数，可以看到运行结果先调用子类的虚构函数，再调用父类的虚构函数。

纯虚函数

◼ 纯虚函数：没有函数体且初始化为0的虚函数，用来定义接口规范

◼ 抽象类（Abstract Class）

• 含有纯虚函数的类，不可以实例化（不可以创建对象）

• 抽象类也可以包含非纯虚函数、成员变量

• 如果父类是抽象类，子类没有完全重写纯虚函数，那么这个子类依然是抽象类

// Java：抽象类、接口
// OC：协议
struct Animal {
   virtual void speak() = 0;
   virtual void run() = 0;
};

抽象类不可以实例化

image-20210407091205245

如果父类是抽象类，子类没有完全重写纯虚函数，那么这个子类依然是抽象类

struct Dog : Animal {
   void run() {
      cout << "Dog::run()" << endl;
   }
};

image-20210407091307309

struct Hashiqi : Dog {
   void speak() {
      cout << "Hashiqi::speak()" << endl;
   }
};

image-20210407091423298

多继承

◼ C++允许一个类可以有多个父类（不建议使用，会增加程序设计复杂度）

image-20210407091538211

struct Student {
   int m_score;
   Student(int score) :m_score(score) {}
   void study() {
      cout << "Student::study() - score = " << m_score << endl;
   }
};

struct Worker {
   int m_salary;
   Worker(int salary) :m_salary(salary) {}
   void work() {
      cout << "Worker::work() - salary = " << m_salary << endl;
   }
};

struct Undergraduate : Student, Worker {
   int m_grade;
   Undergraduate(int score, int salary, int grade) 
      :m_grade(grade), 
      Student(score), 
      Worker(salary) {}
   void play() {
      cout << "Undergraduate::play() - grade = " << m_grade << endl;
   }
};

多继承体系下的构造函数调用

image-20210407091923286

多继承-虚函数

◼ 如果子类继承的多个父类都有虚函数，那么子类对象就会产生对应的多张虚表

image-20210407092036371

同名函数

image-20210407092308828

struct Student {
   void eat() {
      cout << "Student::eat()" << endl;
   }
};

struct Worker {
   void eat() {
      cout << "Worker::eat()" << endl;
   }
};

struct Undergraduate : Student, Worker {
   void eat() {
      cout << "Undergraduate::eat()" << endl;
   }
};

int main() {
Undergraduate ug;
ug.eat();
ug.Student::eat();
ug.Worker::eat();
ug.Undergraduate::eat();

}

输出结果

Undergraduate::eat()
Student::eat()
Worker::eat()
Undergraduate::eat()c

同名成员变量

image-20210407092701439

struct Student {
   int m_age;
};

struct Worker {
   int m_age;
};

struct Undergraduate : Student, Worker {
   int m_age;
};

int main() {

   Undergraduate ug;
   ug.m_age = 10;
   ug.Student::m_age = 11;
   ug.Worker::m_age = 12;
   ug.Undergraduate::m_age = 13;
}

菱形继承

◼ 菱形继承带来的问题

• 最底下子类从基类继承的成员变量冗余、重复

• 最底下子类无法访问基类的成员，有二义性

image-20210407093712205

image-20210407093622982

struct Person {
   int m_age = 1;
};

struct Student :  Person {
   int m_score = 2;
};

struct Worker :  Person {
   int m_salary = 3;
};

struct Undergraduate : Student, Worker {
   int m_grade = 4;
};

int main() {
   Undergraduate ug;

   
   cout << sizeof(Undergraduate) << endl;

   return 0;
}

输出结果

20

最底下子类无法访问基类的成员，有二义性

image-20210407094254494

虚继承

◼ 虚继承可以解决菱形继承带来的问题

◼ Person类被称为==虚基类==

image-20210407094410858

image-20210407094557123

image-20210407095044313

struct Person {
   int m_age = 1;
};

struct Student : virtual Person {
   int m_score = 2;
};

struct Worker : virtual Person {
   int m_salary = 3;
};

struct Undergraduate : Student, Worker {
   int m_grade = 4;
};

int main() {
   Undergraduate ug;

   cout << sizeof(Undergraduate) << endl;

   return 0;
}

输出结果

40

image-20210407100046539

一个指针的大小在64位操作系统是8位，所以8字节对齐。可以看到Undergraduate中内存分布

image-20210407101500522

这张内存虚表的数据和理论不一致，还没研究明白，待验证。

静态成员（static）

◼ 静态成员：被static修饰的成员变量\函数

• 可以通过对象（对象.静态成员）、对象指针（对象指针->静态成员）、类访问（类名::静态成员）

◼ 静态成员变量

• 存储在数据段（全局区，类似于全局变量），整个程序运行过程中只有一份内存

• 对比全局变量，它可以设定访问权限（public、protected、private），达到局部共享的目的

• 必须初始化，必须在类外面初始化，初始化时不能带static，如果类的声明和实现分离（在实现.cpp中初始化）

◼ 静态成员函数

• 内部不能使用this指针（this指针只能用在非静态成员函数内部）

• 不能是虚函数（虚函数只能是非静态成员函数）

• 内部不能访问非静态成员变量\函数，只能访问静态成员变量\函数

• 非静态成员函数内部可以访问静态成员变量\函数

• 构造函数、析构函数不能是静态

• 当声明和实现分离时，实现部分不能带static

class Car {
public:
   int m_age;
   static int m_price;
   static void run() {
      cout << "run()" << endl;
   }
};
// 在类外面初始化成员变量
int Car::m_price = 0;

Car car1;
car1.m_age = 1;
car1.m_price = 2;

Car car2;
car2.m_price = 200;

Car car3;
car3.m_price = 300;

Car *p = new Car();
p->m_price = 400;
delete p;

cout << Car::m_price << endl;