day09：继承

基本语法

减少重复代码

class BasePage {//公共页面
public:
	void header() {
		cout << "title,course,sign in,sign up...(public)" << endl;
	}
	void footer() {
		cout << "help,talk,map...(public)" << endl;
	}
	void left() {
		cout << "java,python,c++...(public)" << endl;
	}
};
class Java :public BasePage {//class 子类:继承方式 父类
public://子类：也称为派生类    父类：也成为基类
	void content() {
		cout << "java video" << endl;
	}
};//派生类中的成员，包含两大部分：一类是从基类继承过来的，一类是自己增加的成员
void test01() {//从基类继承过来的表现其共性，新增的成员表现其个性
	cout << "java video download" << endl;
	Java j;
	j.header();
	j.footer();
	j.left();
	j.content();
	cout << "------------------" << endl;
}

继承方式

继承方式：公共继承，保护继承，私有继承

class Base1 {
public:
	int m_A;
protected:
	int m_B;
private:
	int m_C;
};
class Son1 :public Base1 {//公共继承
public:
	void func() {
		m_A = 1;//基类中的公共权限成员 到派生类中依然是公共权限
		m_B = 1;//基类中的保护权限成员 到派生类中依然是保护权限
		//m_C = 1;//基类中的私有权限成员 派生类不可访问
	}
};
class Son2 :protected Base1 {//保护继承
public:
	void func() {
		m_A = 1;//基类中的公共权限成员 到派生类中变为保护权限
		m_B = 1;//基类中的保护权限成员 到派生类中依然是保护权限
		//m_C = 1;//基类中的私有权限成员 派生类不可访问
	}
};
class Son3 :private Base1 {//私有继承
public:
	void func() {
		m_A = 1;//基类中的公共权限成员 到派生类中变为私有权限
		m_B = 1;//基类中的保护权限成员 到派生类中变为私有权限
		//m_C = 1;//基类中的私有权限成员 派生类不可访问
	}
};
class GrandSon :public Son3 {//公共继承
public:
	void func() {
		//m_A = 100;//在Son3中m_A变为私有权限，即使是派生类，也无法访问
	}
};
void test01() {
	Son1 s1;
	s1.m_A = 10;
	//s2.m_B = 10;//在Son1中m_B变为保护权限，类外不可访问
	Son2 s2;
	//s2.m_A = 10;//在Son2中m_A变为保护权限，类外不可访问
	Son3 s3;
	//s3.m_A = 10;//在Son3中m_A变为私有权限，类外不可访问
}

继承中的对象模型

class Base {
public:
	int m_A;
protected:
	int m_B;
private:
	int m_C;
};
class Son :public Base {
public:
	int m_D;
};//利用开发人员命令提示工具查看对象模型
//跳转根目录盘符 ex：D：+ ENTER；
//跳转文件路径 cd 根目录
//查看命名 cl /d1 reportSingleClassLayout类名 "文件名"
void test01() {
	//基类中所有非静态成员属性都会被派生类继承下去
	//基类中私有成员属性 是被编译器隐藏了，因此访问不到，但会被继承
	cout << sizeof(Son) << endl;
}

继承中构造和析构顺序

class Base {
public:
	Base() {
		cout << "Base构造函数" << endl;
	}
	~Base() {
		cout << "Base析构函数" << endl;
	}
};
class Son :public Base {
public:
	Son() {
		cout << "Son构造函数" << endl;
	}
	~Son() {
		cout << "Son析构函数" << endl;
	}
};
void test01() {
	Son s;//继承中的构造和析构顺序如下
	//先构造基类，再构造派生类，先析构派生类，再析构基类
}

继承中同名成员处理方式

class Base {
public:
	Base() {
		m_A = 10;
	}
	void func() {
		cout << "Base - func()调用" << endl;
	}
	void func(int a) {
		cout << "Base - func(int a)调用" << endl;
	}
	int m_A;
};
class Son :public Base {
public:
	Son() {
		m_A = 9;
	}
	void func() {
		cout << "Son - func()调用" << endl;
	}
	int m_A;
};
void test01() {//同名成员属性处理
	Son s;
	cout << "Son m_A = " << s.m_A << endl;
	//通过派生类访问基类中同名成员，需要加作用域
	cout << "Base m_A = " << s.Base::m_A << endl;
}
void test02() {//同名成员函数
	Son s;
	s.func();//直接调用，调用的是派生类中的成员变量
	s.Base::func();//加作用域
	//如果派生类中出现和基类同名的成员函数，派生类中的同名成员会隐藏掉基类中的所有同名成员函数
	//s.func(100);
	s.Base::func(100);//需要加作用域
}

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

class Base {
public:
	static int m_A;
	static void func() {
		cout << "Base static void fun()" << endl;
	}
};
int Base::m_A = 100;
class Son :public Base {
public:
	static int m_A;
	static void func() {
		cout << "Son static void fun()" << endl;
	}
};
int Son::m_A = 10;
void test01() {//同名静态属性
	Son s;
	//通过对象访问数据
	cout << "static Son m_A = " << s.m_A << endl;
	cout << "static Base m_A = " << s.Base::m_A << endl;
	//通过类名访问数据
	cout << "static class Son m_A = " << Son::m_A << endl;
	//第一个：：表示通过类名方式访问，第二个：：表示访问基类作用域下
	cout << "static class Base m_A = " << Son::Base::m_A << endl;
}
void test02() {//同名静态函数
	Son s;
	//通过对象访问
	s.func();
	s.Base::func();
	//通过类名访问
	Son::func();//派生类出现和基类同名静态成员函数，会隐藏基类中所有同名成员函数
	Son::Base::func();//如果想访问基类中被隐藏同名成员，需要加作用域
}

多继承语法（C++开发中不建议用多继承）

多继承可能会引发父类中有同名成员出现，需要加作用域区分

class Base1 {
public:
	Base1() {
		m_A = 100;
	}
	int m_A;
};
class Base2 {
public:
	Base2() {
		m_A = 200;
	}
	int m_A;
};
class Son :public Base1, public Base2 {//语法 class 派生类 : 继承方式 基类1, 继承方式 基类2...
public:
	Son() {
		m_C = 300;
		m_D = 400;
	}
	int m_C;
	int m_D;
};
void test01() {
	Son s;
	cout << sizeof(s) << endl;
	//当基类中出现同名成员，需要加作用域区分
	cout << "Base1 m_A = " << s.Base1::m_A << endl;
	cout << "Base2 m_A = " << s.Base2::m_A << endl;
}

菱形继承（钻石继承）

两个派生类继承同一个基类，同时又有一个类同时继承两个派生类

菱形继承问题

vbptr：虚基类指针->vbtable：虚基类表格（记录偏移量）

v——virtual

b——base

ptr——pointer

class Animal {
public:
	int m_Age;
};
//利用虚继承，解决菱形继承问题，需要在继承之前加上关键字virtual，称为虚基类
class Sheep :virtual public Animal {};
class Tuo :virtual public Animal {};
class SheepTuo :public Sheep, public Tuo {};
void test01() {
	SheepTuo st;
	st.Sheep::m_Age = 10;
	st.Tuo::m_Age = 20;//当菱形继承，两个基类拥有相同数据，需要加以作用域区分
	cout << "st.Sheep::m_Age = " << st.Sheep::m_Age << endl;
	cout << "st.Tuo::m_Age = " << st.Tuo::m_Age << endl;
	//菱形继承导致数据有两份，资源浪费
	cout << "st.m_Age = " << st.m_Age << endl;
}