day 6 今天学到继承了，但是炼丹还是没什么效果

继承  面向对象的三大特性之一   重点

继承

比如说在实现页面的时候，重复太多了，需要用到继承

class Java 
{
public:
	void header() 
	{
		cout << "首页、公开课、登入、注册...（公共头部）" << endl;
	}

	void footer()
	{
		cout << "帮助中心、交流合作、站内地图...（公共底部）" << endl;
	}
	void left()
	{
		cout << "Java、Python、C++、...（公共分类列表）" << endl;
	}
	void content() 
	{
		cout << "Java学科视频" << endl;
	}

};

//Python

class Python
{
public:
	void header()
	{
		cout << "首页、公开课、登入、注册...（公共头部）" << endl;
	}

	void footer()
	{
		cout << "帮助中心、交流合作、站内地图...（公共底部）" << endl;
	}
	void left()
	{
		cout << "Java、Python、C++、...（公共分类列表）" << endl;
	}
	void content()
	{
		cout << "Python学科视频" << endl;
	}

};
//C++
class CPP
{
public:
	void header()
	{
		cout << "首页、公开课、登入、注册...（公共头部）" << endl;
	}

	void footer()
	{
		cout << "帮助中心、交流合作、站内地图...（公共底部）" << endl;
	}
	void left()
	{
		cout << "Java、Python、C++、...（公共分类列表）" << endl;
	}
	void content()
	{
		cout << "C++学科视频" << endl;
	}

};

可以看到上述代码在每个页面都有很多相同的部分，页面中只有内容会不一样，那么这样我们就可以使用继承，先创建一个父类（基类，下文用父类），然后在创建几个子类（派生类），就可以实现上述功能。

class BasePage 
{
public:
	void header()
	{
		cout << "首页、公开课、登入、注册...（公共头部）" << endl;
	}

	void footer()
	{
		cout << "帮助中心、交流合作、站内地图...（公共底部）" << endl;
	}
	void left()
	{
		cout << "Java、Python、C++、...（公共分类列表）" << endl;
	}
};

class Java : public BasePage  // 继承
{
public:
	void content()
	{
		cout << "Java学科视频" << endl;
	}
};

//Python页面

class Python : public BasePage
{
public:
	void content()
	{
		cout << "Python学科视频" << endl;
	}
};

//CPP页面

class CPP : public BasePage
{
public:
	void content()
	{
		cout << "C++学科视频" << endl;
	}
};

从上述代码中我们可以看到，代码明显洁简了许多，这也就是继承的好处：减少重复的代码。

语法 ： class 子类 ： 继承方式 父类

子类 也称为 派生类

父类 也称为 基类

继承的方式

继承有三种方式： 公共继承 保护继承 私有继承  分别对应着 public protected private   父类中的私有属性，子类无法访问

公共继承

class Base1 
{
public:
	int m_a;
protected:
	int m_b;
private:
	int m_c;
};

先来创建一个父类，分别有三个属性，公共属性，保护属性，私有属性，接着创建一个子类，继承上述的父类，继承方式是公共继承。我们发现到第三行的时候m_c = 10；就会出现问题，显示无法访问。

class Son1 : public Base1
{
public:
	void func() 
	{
		m_a = 10;//父类中的公共权限成员 到子类中依然是公共权限
		m_b = 10; //父类中的保护权限的成员 到了子类中依然是保护权限
		//m_c = 10;//父类中私有权限成员   子类无法访问
	}
};

void test01() 
{
	Son1 s1;
	s1.m_a = 100;//公共权限，类内能访问类外也能访问
	s1.m_b = 100;//保护权限内容 类外无法访问 类内可以访问
}

当子类用的是公共继承的时候 ， 父类中的 公共属性 ， 保护属性 ， 私有属性 ， 会不动的继承给子类 。 

保护继承

当子类使用的是保护继承的时候 ， 父类中的 公共属性 ， 保护属性 ， 私有属性 ，到了子类公共属性和保护属性 会变成子类的保护属性，而私有属性依旧还是私有的。

class Son2 : protected Base2
{
public:
	void func() 
	{
		m_a = 100;//父类中公共成员到子类中变为保护权限
		m_b = 100;//父类中保护成员到子类中也为保护权限
		//m_c = 100;//父类中私有成员子类访问不到
	}
};
void test02()
{
	Son2 s2;
	//s1.m_a = 100;//保护权限内容 类外无法访问 类内可以访问
	//s1.m_b = 100;//保护权限内容 类外无法访问 类内可以访问
}

私有继承

当子类使用的是私有继承的时候 ， 父类中的 公共属性 ， 保护属性 ， 私有属性 ，到了子类中全为 私有属性。

class Son3 : private Base3
{
public:
	void func()
	{
		m_a = 100; // 父类中公共成员到子类中变为私有成员
		m_b = 100;//父类中保护的成员到子类中变为私有成员
		//m_c = 100; // 父类中私有成员 子类访问不到
	}
};
void test02()
{
	Son3 s3;
	//s3.m_a = 100;//到了s3中变为私有成员，类外访问不到
	//s3.m_b = 100;//到了s3中变为私有成员，类外访问不到
}

class GrandSon3 : public Son3 
{
public:
	void func() 
	{
		m_a = 1000; // 到了son3中 m_a已经变为私有 已经访问不到了
	}
};

由于到了s3 的时候，所有父类的属性均变为了私有属性，所以到了grandson3的时候都访问不到了。

继承中的对象模型

可以利用开发人员命令提示工具查看对象模型

首先先跳转盘符 然后到相应的目录下，dir查看目录中已有的文件(windows操作系统下)，接着使用命令

cl /d1 reportSingleClassLayout类名 文件名.cpp   便可查看

class Base
{
public:
	int m_a;
protected:
	int m_b;
private:
	int m_c;
};
class Son :public Base 
{
public:
	int m_d;
};

继承中构造和析构的顺序

子类继承父类后，当创建子类对象，也会调用父类的构造函数  ， 继承中的构造和析构顺序如下 ：先构造父类，再构造子类，析构的顺序和构造相反

继承同名成员处理方式

访问子类同名成员，直接访问即可

访问父类同名成员，需要加作用域

class Base 
{
public:
	Base() 
	{
		m_a = 100;
	}
	int m_a;
};

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

	int m_a;
};

首先先定义一个父类和一个子类，可以看到他们有相同命名的属性m_a，那么如何才能访问到父类中的m_a呢？

void test01() 
{
	Son S;
	cout << "Son 下 m_a = " << S.m_a << endl;
	//如果通过子类对象访问到父类中的同名成员、函数需要加一个作用域
	cout << "Base 下 m_a = " << S.Base::m_a << endl; 
}

当子类与父类拥有同名成员函数，子类会隐藏父类中同名的成员函数，加作用域可以访问到父类中的同名函数。

继承同名静态成员处理方式， 静态成员需要类内声明类外初始化。

静态成员和非静态成员出现同名。处理方式一致。

class Base 
{
public:
	static void func() 
	{
		cout << "Base -static void func()" << endl;
	}
	static int m_a;
};
int Base::m_a = 100;

class Son :public Base 
{
public:
	static void func()
	{
		cout << "Son -static void func()" << endl;
	}
	static int m_a;
};
int Son::m_a = 200;
//同名静态成员属性
void test01() 
{
	//1、通过对象访问
	cout << "通过对象访问" << endl;
	Son s;
	cout << "Son 下 m_a = " << s.m_a<< endl;

	cout << "Base 下 m_a = " << s.Base::m_a << endl;

	//2、通过类名访问
	cout << "通过类名访问" << endl;
	cout << "Son 下 m_a = " << Son::m_a << endl;
	//第一个双冒号代表通过类名方式访问  第二个代表访问父类作用域下
	cout << "Base 下 m_a = " << Son::Base::m_a << endl;
}
//同名静态成员函数
void test02() 
{
	//1、通过对象访问
	cout << "通过对象访问" << endl;
	Son s;
	s.func();
	s.Base::func();
	cout << "通过类名访问" << endl;
	//2、通过类名访问
	Son::func();
	Son::Base::func();
}

多继承

语法 ： class 子类 ： 继承方式 父类1，继承方式 父类2{};

C++允许一个类继承多个类  多继承可能会引发父类中有同名成员出现，需要加作用域。

C++实际开发中不建议使用多继承。

菱形继承

概念 ： 两个派生类继承同一个基类 ,  又有某个类同时继承着两个派生类 , 这种继承被称为菱形继承 或者钻石继承。

class sheep : public animal
{

};

class tuo :public animal 
{

};

class sheeptuo :public sheep, public tuo 
{

};

void test01() 
{
	sheeptuo st;
	st.sheep::m_age = 18;
	st.tuo::m_age = 28;
	//当菱形继承的时候，两个父类拥有相同的数据，需要加以作用域区分 
	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;
}

为了克服上述菱形继承的问题，我们需要引入一个 虚继承

在继承之前加上关键字virtual变为虚继承

animal称为 虚基类  

class animal   //虚基类
{
public:
	int m_age;
};

class sheep :virtual public animal
{

};

class tuo :virtual public animal 
{

};

class sheeptuo :public sheep, public tuo 
{

};

这时候需要了解这块代码的底层含义， 定义了这个之后会有vbptr ， 即虚基类指针  v virtual b base ptr pointer  这个指针指向vbtable，我们需要使用上述学到的知识，就是使用开发人员命令提示工具查看对象模型。

红色线条的虚基类指针指向sheep的虚基类表中的8 ， 那么 0 + 8 指向的就是m_age , 蓝色线条的指向tuo中的虚基类表中的4 那么4+4 m_age 。 

这样就只需要一份这个数据就可以了。

总结 ： 菱形继承带来的主要问题是子类继承两份相同的数据，导致资源浪费以及毫无意义 ， 利用虚继承可以解决菱形继承的问题 。