C++继承

继承，可以让子类拥有父类的所有成员（函数，变量）

普通继承

class Person {
  int m_age;

  void run() {
    std::cout << "Person::run()" << std::endl;
  }
};

class Student : Person {
  int m_id;

  void study() { 
    std::cout << "Student::study()" << std::endl;
  }
};

 

 三种权限继承：

1. public：公共的，任何地方都可以访问 (struct默认)

2. protected：当前类内部，子类内部可以访问

3. private：只当前类内部可以访问（class默认）

当继承权限与类本身的权限冲突时，取更小的，更严苛的那个权限。

class Person {
  int m_age;

  void run() {
    std::cout << "Person::run()" << std::endl;
  }
};

class Student : public Person {
  int m_id;

  void study() { 
    std::cout << "Student::study()" << std::endl;
  }
};

以上的例子只提供了公有继承，一般来讲，推荐共有继承，这样就不会破坏父类原有的权限了。

父类的构造函数：

1. 子类的构造函数在一开始会先调用父类的无参构造函数

2. 如果子类显示的调用了父类的有参构造函数，就不会再调用无参构造函数

3. 如果父类没有无参构造函数，必须显式调用父类的有参构造函数

4. 如果父类没有构造函数，就不调用了 

5. 显式调用父类的构造函数，必须写在初始化列表中

#include <iostream>

class Person {
 public:
  int m_age;

  Person() : m_age(10) {
    std::cout << "你xx" << std::endl;
  }
  
  void run() {
    std::cout << "Person::run()" << std::endl;
  }
};

class Student : public Person {
 public:
  int m_id;

  Student() : Person::Person(), m_id(10) {
    std::cout << "我xx" << std::endl;
  }

  void study() { 
    std::cout << "Student::study()" << std::endl;
  }
};

int main(void) {
  Student s;

  return 0;
}

多态（虚继承）

多态的要素：

1. 子类重写父类成员函数

2. 父类指针指向子类对象

3. 利用父类指针调用重写的成员函数

C++中的多态由虚函数实现（虚函数：被virtual关键字修饰的函数）只要父类的某个成员函数是虚函数，子类重写该函数之后，也还是虚函数，不需要再用virtual关键字修饰一遍。

#include <iostream>

class Animal {
 public:
  int m_age;

  virtual void smile() = 0; //纯虚函数

  virtual void speak() {
    std::cout << "Animal::speak()" << std::endl;
  }

  virtual void run() { 
    std::cout << "Animal::run()" << std::endl;
  }
};

class Cat : public Animal {
 public:
  int m_id;

  void smile() {
    std::cout << "Cat::smile()" << std::endl;
  }

  void speak() {
    std::cout << "Cat::speak()" << std::endl;
  }

  void run() {
    std::cout << "Cat::run()" << std::endl;
  }
};

int main(void) {
  Animal* p = new Cat;
  
  p->speak();
  p->run();
  p->smile();

  return 0;
}

值得注意的是，纯虚函数必须在子类中重写。

虚表

虚表才是多态能够实现的真相。虚表是一段连续的内存空间，存放着虚函数的地址

#include <iostream>

class Animal {
 public:
  int m_age;

  virtual void speak() {
    std::cout << "Animal::speak()" << std::endl;
  }

  virtual void run() { 
    std::cout << "Animal::run()" << std::endl;
  }
};

class Cat : public Animal {
 public:
  int m_life;

  void speak() {
    std::cout << "Cat::speak()" << std::endl;
  }

  void run() {
    std::cout << "Cat::run()" << std::endl;
  }
};

int main(void) {
  Animal* p = new Cat;
  
  p->speak();
  p->run();

  return 0;
}

 加入了虚函数，Cat在创建对象时就会多一个指针，放在最前面，指向存放Cat重写的虚函数的地址。

值得一提的是：

1. 创建什么类型的对象就载入什么类型的虚表

2. 相同类型共用一张虚表

3. 子类没有重写虚函数，就沿用父类的虚表。 

虚函数相关注意事项：

1. 有父类指针指向子类指针，那么将析构函数也声明为虚函数，这样delete父类指针的时候，才会调用子类的析构函数，而不是调用父类的。（父类和子类析构函数都要添加virtual关键字）

2. 含有纯虚函数的类为抽象类，不可实例化对象，如果子类没把父类的全部纯虚函数重写，那么子类也是抽象类。 

多继承（☞一个子类继承多个父类）

1. 父类成员变量的先后取决于谁先被继承

2. 几个父类有虚函数，子类就有几个虚表 

菱形继承

危害：相同的成员被多次继承

  

  

 把重复继承的变量放在最下面，虚表中记录就是，指针到重复继承变量的距离（内存大小）。