C++基础-继承

目的：减少重复代码

基本语法

语法：class 子类(派生类) : 继承方式 父类(基类)

class Animal {
  ...
};

class Dog : public Animal {
  ...
};

继承方式

父类private任何继承方式都无法被访问

• 公共继承(public)
  父类: public -> 子类: public
  父类: protected -> 子类: protected
• 保护继承(protected)
  父类: public -> 子类: protected
  父类: protected -> 子类: protected
• 私有继承(private)
  父类: public -> 子类: private
  父类: protected -> 子类: private

继承中的对象模型

• 父类中所有非静态成员属性都会被子类继承下去
• 父类私有成员属性被编译器隐藏了，因此访问不到，但也被继承了
• 关于类中的静态成员

class Base {
public:
  int A;
  static int A1;
protected:
  int B;
private:
  int C;
};

class Son : public Base {
public:
  int D;
};

sizeof(Son);  // 输出16字节，继承的三个非静态成员加上自身的一个成员

继承中的构造和析构顺序

• 构造：先父类，后子类
• 析构：先子类，后父类

继承同名成员处理方式

• 访问子类同名成员，直接访问即可
• 访问父类同名成员，需要加作用域
• 如果子类中出现和父类同名的成员函数，那么子类会隐藏父类中所有的同名成员函数，需要加作用域才能访问

// 同名属性
class Base {
public:
  Base() {
    A = 100;
  }
  int A;
};

class Son : public Base {
public:
  Son() {
    A = 200;
  }
  int A;
};

Son s;
s.A;        // 输出200
s.Base::A;  // 输出100

// 同名函数
class Base {
public:
  void func(){
    cout << "Base函数调用" << endl;
  };
  void func(int a){
    cout << "Base重载函数调用" << endl;
  };
};

class Son : public Base {
public:
  void func(){
    cout << "Son函数调用" << endl;
  };
};

Son s;
s.func();          // 输出"Base函数调用"
s.Base::func();    // 输出"Son函数调用"
s.Base::func(10);  // 输出"Base重载函数调用"

继承同名静态成员处理方式

// 同名静态成员变量
class Base {
public:
    static int A;
};

int Base::A = 10;  // 类中静态成员初始化

class Son : public Base {
public:
    static int A;
};

int Son::A = 20;  // 类中静态成员初始化

// 通过对象访问静态成员
Son s;
s.A;
s.Base::A;

// 通过类名访问静态成员
Son::A;
Base::A;
Son::Base::A;

// 同名静态成员函数
class Base {
public:
  static void func(){
    cout << "Base函数调用" << endl;
  };
};

class Son : public Base {
public:
  static void func(){
    cout << "Son函数调用" << endl;
  };
};

// 通过对象访问静态成员
Son s;
s.func();          
s.Base::func();    

// 通过类名访问静态成员
Son::func();
Base::func();       
Son::Base::func();  

多继承语法

语法：class 子类 : 继承方式 父类1, 继承方式 父类2, ...
出现同名成员变量和函数要用作用域区分

菱形继承

Base->A, Base->B;
A->C, B->C;

• A继承了Base数据，B也继承了Base数据，当C使用数据时，会产生二义性。需要加作用域区分
• 对C来说，Base的数据只需一份。利用虚继承解决

class Base {
public:
  int a;
};

class A : public  Base {};
class B : public  Base {};
class C : public  A, public B {};

// 加作用域访问
C c;
c.A::a;
c.B::a;
sizeof(C);  // 输出8字节，有两份a

// 虚基类
class Base {
public:
  int a;
};

// 加virtual，虚继承
class A : virtual public  Base {};
class B : virtual public  Base {};
class C : public  A, public B {};

// 加作用域访问
C c;
c.A::a = 10;
c.B::a = 20;
c.a;  // 输出20
sizeof(C);  // 输出24字节，因为产生了虚基类指针和虚基类表，通过偏移量来获得age